﻿namespace ACCOUNTING.My
{
    using ACCOUNTING;
    using Microsoft.VisualBasic;
    using Microsoft.VisualBasic.ApplicationServices;
    using Microsoft.VisualBasic.CompilerServices;
    using System;
    using System.CodeDom.Compiler;
    using System.Collections;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Diagnostics;
    using System.Reflection;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Windows.Forms;

    [GeneratedCode("MyTemplate", "8.0.0.0"), HideModuleName, StandardModule]
    internal sealed class MyProject
    {
        private static readonly ThreadSafeObjectProvider<MyApplication> m_AppObjectProvider = new ThreadSafeObjectProvider<MyApplication>();
        private static readonly ThreadSafeObjectProvider<MyComputer> m_ComputerObjectProvider = new ThreadSafeObjectProvider<MyComputer>();
        private static ThreadSafeObjectProvider<MyForms> m_MyFormsObjectProvider = new ThreadSafeObjectProvider<MyForms>();
        private static readonly ThreadSafeObjectProvider<MyWebServices> m_MyWebServicesObjectProvider = new ThreadSafeObjectProvider<MyWebServices>();
        private static readonly ThreadSafeObjectProvider<Microsoft.VisualBasic.ApplicationServices.User> m_UserObjectProvider = new ThreadSafeObjectProvider<Microsoft.VisualBasic.ApplicationServices.User>();

        [HelpKeyword("My.Application")]
        internal static MyApplication Application
        {
            [DebuggerHidden]
            get
            {
                return m_AppObjectProvider.GetInstance;
            }
        }

        [HelpKeyword("My.Computer")]
        internal static MyComputer Computer
        {
            [DebuggerHidden]
            get
            {
                return m_ComputerObjectProvider.GetInstance;
            }
        }

        [HelpKeyword("My.Forms")]
        internal static MyForms Forms
        {
            [DebuggerHidden]
            get
            {
                return m_MyFormsObjectProvider.GetInstance;
            }
        }

        [HelpKeyword("My.User")]
        internal static Microsoft.VisualBasic.ApplicationServices.User User
        {
            [DebuggerHidden]
            get
            {
                return m_UserObjectProvider.GetInstance;
            }
        }

        [HelpKeyword("My.WebServices")]
        internal static MyWebServices WebServices
        {
            [DebuggerHidden]
            get
            {
                return m_MyWebServicesObjectProvider.GetInstance;
            }
        }

        [MyGroupCollection("System.Windows.Forms.Form", "Create__Instance__", "Dispose__Instance__", "My.MyProject.Forms"), EditorBrowsable(EditorBrowsableState.Never)]
        internal sealed class MyForms
        {
            [ThreadStatic]
            private static Hashtable m_FormBeingCreated;
            public ACCOUNTING.Frm_AddDonViTinh m_Frm_AddDonViTinh;
            public ACCOUNTING.Frm_AddHoaDonBanHang m_Frm_AddHoaDonBanHang;
            public ACCOUNTING.Frm_AddThanhToanMuaHang m_Frm_AddThanhToanMuaHang;
            public ACCOUNTING.Frm_BanGiaoSuaChua m_Frm_BanGiaoSuaChua;
            public ACCOUNTING.Frm_BangKeHoaDonMuaDichVu m_Frm_BangKeHoaDonMuaDichVu;
            public ACCOUNTING.Frm_BanHang m_Frm_BanHang;
            public ACCOUNTING.Frm_BaoCaoDoanhThuTheoNhanVien m_Frm_BaoCaoDoanhThuTheoNhanVien;
            public ACCOUNTING.Frm_BaoCoNganHang m_Frm_BaoCoNganHang;
            public ACCOUNTING.Frm_BaoCoNganHangList m_Frm_BaoCoNganHangList;
            public ACCOUNTING.Frm_BaoGia m_Frm_BaoGia;
            public ACCOUNTING.Frm_BaoGiaList m_Frm_BaoGiaList;
            public ACCOUNTING.Frm_BaoNoNganHang m_Frm_BaoNoNganHang;
            public ACCOUNTING.Frm_BaoNoNganHangList m_Frm_BaoNoNganHangList;
            public ACCOUNTING.Frm_BCPhatHanhHoaDon m_Frm_BCPhatHanhHoaDon;
            public ACCOUNTING.Frm_BCTinhHinhSuDungHoaDon m_Frm_BCTinhHinhSuDungHoaDon;
            public ACCOUNTING.Frm_CanhBaoHangTonKho m_Frm_CanhBaoHangTonKho;
            public ACCOUNTING.Frm_CanTruCongNo m_Frm_CanTruCongNo;
            public ACCOUNTING.Frm_CanTruCongNoList m_Frm_CanTruCongNoList;
            public ACCOUNTING.Frm_CapNhatDienGiai m_Frm_CapNhatDienGiai;
            public ACCOUNTING.Frm_CapNhatGiaBan m_Frm_CapNhatGiaBan;
            public ACCOUNTING.Frm_CapNhatGiaMua m_Frm_CapNhatGiaMua;
            public ACCOUNTING.Frm_CapNhatGiaVonXuatKho m_Frm_CapNhatGiaVonXuatKho;
            public ACCOUNTING.Frm_CapNhatSoDuDauKyHangHoaTheoLo m_Frm_CapNhatSoDuDauKyHangHoaTheoLo;
            public ACCOUNTING.Frm_CapNhatSoDuDauKyTaiKhoan m_Frm_CapNhatSoDuDauKyTaiKhoan;
            public ACCOUNTING.Frm_CapNhatSoDuHangHoa m_Frm_CapNhatSoDuHangHoa;
            public ACCOUNTING.Frm_ChiPhiMuaHang m_Frm_ChiPhiMuaHang;
            public ACCOUNTING.Frm_ChiPhiMuaHangList m_Frm_ChiPhiMuaHangList;
            public ACCOUNTING.Frm_ChiPhiTraTruoc m_Frm_ChiPhiTraTruoc;
            public ACCOUNTING.Frm_ChonHangTraLai m_Frm_ChonHangTraLai;
            public ACCOUNTING.Frm_ChonHangTuGiaoHang m_Frm_ChonHangTuGiaoHang;
            public ACCOUNTING.Frm_ChungTuTongHop m_Frm_ChungTuTongHop;
            public ACCOUNTING.Frm_ChungTuTongHopList m_Frm_ChungTuTongHopList;
            public ACCOUNTING.Frm_ChuyenDuLieuDanhMucSangChiNhanh m_Frm_ChuyenDuLieuDanhMucSangChiNhanh;
            public ACCOUNTING.Frm_ClearData m_Frm_ClearData;
            public ACCOUNTING.Frm_CongNoPhaiThu m_Frm_CongNoPhaiThu;
            public ACCOUNTING.Frm_DangKyBanQuyen m_Frm_DangKyBanQuyen;
            public ACCOUNTING.Frm_DangKyDuLieu m_Frm_DangKyDuLieu;
            public ACCOUNTING.Frm_DangKyHoaDon m_Frm_DangKyHoaDon;
            public ACCOUNTING.Frm_DangKyHoaDonList m_Frm_DangKyHoaDonList;
            public ACCOUNTING.Frm_DanhSachHoaDonHuy m_Frm_DanhSachHoaDonHuy;
            public ACCOUNTING.Frm_DanhSachNguoiDung m_Frm_DanhSachNguoiDung;
            public ACCOUNTING.Frm_DanhSachSanPhamDoDang m_Frm_DanhSachSanPhamDoDang;
            public ACCOUNTING.Frm_DanhSachTaiSanCoDinh m_Frm_DanhSachTaiSanCoDinh;
            public ACCOUNTING.Frm_DanhSachXacNhanDonHang m_Frm_DanhSachXacNhanDonHang;
            public ACCOUNTING.Frm_DatabaseChiNhanh m_Frm_DatabaseChiNhanh;
            public ACCOUNTING.Frm_Dictionary m_Frm_Dictionary;
            public ACCOUNTING.Frm_DieuKhoanBaoGia m_Frm_DieuKhoanBaoGia;
            public ACCOUNTING.Frm_DinhKhoanNhapKhau m_Frm_DinhKhoanNhapKhau;
            public ACCOUNTING.Frm_DinhKhoanPhieuNhapKho m_Frm_DinhKhoanPhieuNhapKho;
            public ACCOUNTING.Frm_DinhKhoanTraHang m_Frm_DinhKhoanTraHang;
            public ACCOUNTING.Frm_DinhKhoanXuatBan m_Frm_DinhKhoanXuatBan;
            public ACCOUNTING.Frm_DinhNghiaCanDoiKeToan m_Frm_DinhNghiaCanDoiKeToan;
            public ACCOUNTING.Frm_DinhNghiaChiNhanh m_Frm_DinhNghiaChiNhanh;
            public ACCOUNTING.Frm_DinhNghiaKetChuyenChiPhiTraTruoc m_Frm_DinhNghiaKetChuyenChiPhiTraTruoc;
            public ACCOUNTING.Frm_DinhNghiaPhuTung m_Frm_DinhNghiaPhuTung;
            public ACCOUNTING.Frm_DinhNghiaTaiKhoanKetChuyen m_Frm_DinhNghiaTaiKhoanKetChuyen;
            public ACCOUNTING.Frm_DKHangHoa m_Frm_DKHangHoa;
            public ACCOUNTING.Frm_DKKhachHang m_Frm_DKKhachHang;
            public ACCOUNTING.Frm_DMChiPhi m_Frm_DMChiPhi;
            public ACCOUNTING.Frm_DMDieuKhoanBaoGia m_Frm_DMDieuKhoanBaoGia;
            public ACCOUNTING.Frm_DMDonViBoPhan m_Frm_DMDonViBoPhan;
            public ACCOUNTING.Frm_DMDonViTinh m_Frm_DMDonViTinh;
            public ACCOUNTING.Frm_DMHangHoa m_Frm_DMHangHoa;
            public ACCOUNTING.Frm_DMHangMucBaoCaoThue m_Frm_DMHangMucBaoCaoThue;
            public ACCOUNTING.Frm_DMHangMucSuaChua m_Frm_DMHangMucSuaChua;
            public ACCOUNTING.Frm_DMHangSanXuat m_Frm_DMHangSanXuat;
            public ACCOUNTING.Frm_DMHopDong m_Frm_DMHopDong;
            public ACCOUNTING.Frm_DMKhachHang m_Frm_DMKhachHang;
            public ACCOUNTING.Frm_DMKho m_Frm_DMKho;
            public ACCOUNTING.Frm_DMKhoanMucChiPhi m_Frm_DMKhoanMucChiPhi;
            public ACCOUNTING.Frm_DMKhuVuc m_Frm_DMKhuVuc;
            public ACCOUNTING.Frm_DMLienHeDoiTuong m_Frm_DMLienHeDoiTuong;
            public ACCOUNTING.Frm_DMLoaiGia m_Frm_DMLoaiGia;
            public ACCOUNTING.Frm_DMLoaiHoaDon m_Frm_DMLoaiHoaDon;
            public ACCOUNTING.Frm_DMLoaiKhachHang m_Frm_DMLoaiKhachHang;
            public ACCOUNTING.Frm_DMLoaiNhapXuat m_Frm_DMLoaiNhapXuat;
            public ACCOUNTING.Frm_DMLoaiTaiSan m_Frm_DMLoaiTaiSan;
            public ACCOUNTING.Frm_DMLoaiTien m_Frm_DMLoaiTien;
            public ACCOUNTING.Frm_DMLyDoTangGiamTaiSan m_Frm_DMLyDoTangGiamTaiSan;
            public ACCOUNTING.Frm_DMNganHang m_Frm_DMNganHang;
            public ACCOUNTING.Frm_DMNganhHang m_Frm_DMNganhHang;
            public ACCOUNTING.Frm_DMNganhKinhDoanh m_Frm_DMNganhKinhDoanh;
            public ACCOUNTING.Frm_DMNhaCungCap m_Frm_DMNhaCungCap;
            public ACCOUNTING.Frm_DMNhanVien m_Frm_DMNhanVien;
            public ACCOUNTING.Frm_DMNhomHangHoa m_Frm_DMNhomHangHoa;
            public ACCOUNTING.Frm_DMPhuongThucTamUng m_Frm_DMPhuongThucTamUng;
            public ACCOUNTING.Frm_DMPhuongThucThanhToan m_Frm_DMPhuongThucThanhToan;
            public ACCOUNTING.Frm_DMPhuongThucVanChuyen m_Frm_DMPhuongThucVanChuyen;
            public ACCOUNTING.Frm_DMPhuTungTaiSan m_Frm_DMPhuTungTaiSan;
            public ACCOUNTING.Frm_DMQuocGia m_Frm_DMQuocGia;
            public ACCOUNTING.Frm_DMSanPhamCongViec m_Frm_DMSanPhamCongViec;
            public ACCOUNTING.Frm_DMTaiKhoan m_Frm_DMTaiKhoan;
            public ACCOUNTING.Frm_DMThongSoHangHoa m_Frm_DMThongSoHangHoa;
            public ACCOUNTING.Frm_DMTinhThanh m_Frm_DMTinhThanh;
            public ACCOUNTING.Frm_DMViTri m_Frm_DMViTri;
            public ACCOUNTING.Frm_DoiMatKhau m_Frm_DoiMatKhau;
            public ACCOUNTING.Frm_DoiTuongThue m_Frm_DoiTuongThue;
            public ACCOUNTING.Frm_DonDatHangBan m_Frm_DonDatHangBan;
            public ACCOUNTING.Frm_DonDatHangBanList m_Frm_DonDatHangBanList;
            public ACCOUNTING.Frm_DonDatHangMua m_Frm_DonDatHangMua;
            public ACCOUNTING.Frm_DonDatHangMuaList m_Frm_DonDatHangMuaList;
            public ACCOUNTING.Frm_DSMauHoaDon m_Frm_DSMauHoaDon;
            public ACCOUNTING.Frm_DuLieuThue m_Frm_DuLieuThue;
            public ACCOUNTING.Frm_DuyetDonHangBan m_Frm_DuyetDonHangBan;
            public ACCOUNTING.Frm_GetData m_Frm_GetData;
            public ACCOUNTING.Frm_GetDataFromLocalSystem m_Frm_GetDataFromLocalSystem;
            public ACCOUNTING.Frm_GhiGiamTaiSan m_Frm_GhiGiamTaiSan;
            public ACCOUNTING.Frm_GhiGiamTaiSanList m_Frm_GhiGiamTaiSanList;
            public ACCOUNTING.Frm_GhiSoTraHangNhaCungCap m_Frm_GhiSoTraHangNhaCungCap;
            public ACCOUNTING.Frm_GhiSoXuatKho m_Frm_GhiSoXuatKho;
            public ACCOUNTING.Frm_GiaTriMacDinh m_Frm_GiaTriMacDinh;
            public ACCOUNTING.Frm_HangHoa m_Frm_HangHoa;
            public ACCOUNTING.Frm_HangTrenDuongVe m_Frm_HangTrenDuongVe;
            public ACCOUNTING.Frm_HienThiChucNang m_Frm_HienThiChucNang;
            public ACCOUNTING.Frm_HienThiDuLieu m_Frm_HienThiDuLieu;
            public ACCOUNTING.Frm_HinhKyTenDongDau m_Frm_HinhKyTenDongDau;
            public ACCOUNTING.Frm_HoaDonBanDichVu m_Frm_HoaDonBanDichVu;
            public ACCOUNTING.Frm_HoaDonBanDichVuList m_Frm_HoaDonBanDichVuList;
            public ACCOUNTING.Frm_HoaDonChiNhanh m_Frm_HoaDonChiNhanh;
            public ACCOUNTING.Frm_HoaDonChiNhanhList m_Frm_HoaDonChiNhanhList;
            public ACCOUNTING.Frm_HoaDonMuaDichVu m_Frm_HoaDonMuaDichVu;
            public ACCOUNTING.Frm_HoaDonMuaDichVuList m_Frm_HoaDonMuaDichVuList;
            public ACCOUNTING.Frm_HoaDonNhapKhauNoThanhToan m_Frm_HoaDonNhapKhauNoThanhToan;
            public ACCOUNTING.Frm_HoaHongList m_Frm_HoaHongList;
            public ACCOUNTING.Frm_HopDongBan m_Frm_HopDongBan;
            public ACCOUNTING.Frm_HopDongBanList m_Frm_HopDongBanList;
            public ACCOUNTING.Frm_HopDongMua m_Frm_HopDongMua;
            public ACCOUNTING.Frm_HopDongMuaBan m_Frm_HopDongMuaBan;
            public ACCOUNTING.Frm_HopDongMuaBanList m_Frm_HopDongMuaBanList;
            public ACCOUNTING.Frm_HopDongMuaList m_Frm_HopDongMuaList;
            public ACCOUNTING.Frm_InHoaDonTuIn m_Frm_InHoaDonTuIn;
            public ACCOUNTING.Frm_InUyNhiemChi m_Frm_InUyNhiemChi;
            public ACCOUNTING.Frm_KetChuyenCacKhoanGiamTruVaThue m_Frm_KetChuyenCacKhoanGiamTruVaThue;
            public ACCOUNTING.Frm_KetChuyenChiPhi m_Frm_KetChuyenChiPhi;
            public ACCOUNTING.Frm_KetChuyenSoDu m_Frm_KetChuyenSoDu;
            public ACCOUNTING.Frm_KetNoiCSDL m_Frm_KetNoiCSDL;
            public ACCOUNTING.Frm_KeToan m_Frm_KeToan;
            public ACCOUNTING.Frm_GiaThanh m_Frm_GiaThanh;
            public ACCOUNTING.Frm_KhachHang m_Frm_KhachHang;
            public ACCOUNTING.Frm_KhachHangThanhToan m_Frm_KhachHangThanhToan;
            public ACCOUNTING.Frm_KhachHangTraHang m_Frm_KhachHangTraHang;
            public ACCOUNTING.Frm_KhachHangTraHangList m_Frm_KhachHangTraHangList;
            public ACCOUNTING.Frm_KhachHangUngTruoc m_Frm_KhachHangUngTruoc;
            public ACCOUNTING.Frm_KhachHangUngTruocList m_Frm_KhachHangUngTruocList;
            public ACCOUNTING.Frm_KhaiBaoThue m_Frm_KhaiBaoThue;
            public ACCOUNTING.Frm_KhauHaoTaiSan m_Frm_KhauHaoTaiSan;
            public ACCOUNTING.Frm_KhoaSo m_Frm_KhoaSo;
            public ACCOUNTING.Frm_KhoHang m_Frm_KhoHang;
            public ACCOUNTING.Frm_KiemKeHangTonKho m_Frm_KiemKeHangTonKho;
            public ACCOUNTING.Frm_KiemTraDuLieu m_Frm_KiemTraDuLieu;
            public ACCOUNTING.Frm_KiemTraThietBi m_Frm_KiemTraThietBi;
            public ACCOUNTING.Frm_Login m_Frm_Login;
            public ACCOUNTING.Frm_main m_Frm_main;
            public ACCOUNTING.Frm_Matching m_Frm_Matching;
            public ACCOUNTING.Frm_MatchingList m_Frm_MatchingList;
            public ACCOUNTING.Frm_MayChuChiNhanh m_Frm_MayChuChiNhanh;
            public ACCOUNTING.Frm_MuaHang m_Frm_MuaHang;
            public ACCOUNTING.Frm_NamThang m_Frm_NamThang;
            public ACCOUNTING.Frm_NguoiDung m_Frm_NguoiDung;
            public ACCOUNTING.Frm_NhanDuLieu m_Frm_NhanDuLieu;
            public ACCOUNTING.Frm_NhanDuLieuTuChiNhanh m_Frm_NhanDuLieuTuChiNhanh;
            public ACCOUNTING.Frm_NhapDuLieu m_Frm_NhapDuLieu;
            public ACCOUNTING.Frm_NhapKhau m_Frm_NhapKhau;
            public ACCOUNTING.Frm_NhapKhauList m_Frm_NhapKhauList;
            public ACCOUNTING.Frm_NhapKho m_Frm_NhapKho;
            public ACCOUNTING.Frm_NhapKhoList m_Frm_NhapKhoList;
            public ACCOUNTING.Frm_NhapKhoNoiBo m_Frm_NhapKhoNoiBo;
            public ACCOUNTING.Frm_NhapKhoNoiBoList m_Frm_NhapKhoNoiBoList;
            public ACCOUNTING.Frm_NhapSoSeri m_Frm_NhapSoSeri;
            public ACCOUNTING.Frm_NhatKyChungTu m_Frm_NhatKyChungTu;
            public ACCOUNTING.Frm_NopThue m_Frm_NopThue;
            public ACCOUNTING.Frm_NopThueNhapKhau m_Frm_NopThueNhapKhau;
            public ACCOUNTING.Frm_PhaiThu m_Frm_PhaiThu;
            public ACCOUNTING.Frm_PhaiThuList m_Frm_PhaiThuList;
            public ACCOUNTING.Frm_PhaiTra m_Frm_PhaiTra;
            public ACCOUNTING.Frm_PhaiTraList m_Frm_PhaiTraList;
            public ACCOUNTING.Frm_PhanBoChietKhau m_Frm_PhanBoChietKhau;
            public ACCOUNTING.Frm_PhanBoChiPhi m_Frm_PhanBoChiPhi;
            public ACCOUNTING.Frm_PhanBoChiPhiTraTruoc m_Frm_PhanBoChiPhiTraTruoc;
            public ACCOUNTING.Frm_PhieuChi m_Frm_PhieuChi;
            public ACCOUNTING.Frm_PhieuChiList m_Frm_PhieuChiList;
            public ACCOUNTING.Frm_PhieuGiaoHang m_Frm_PhieuGiaoHang;
            public ACCOUNTING.Frm_PhieuGiaoHangList m_Frm_PhieuGiaoHangList;
            public ACCOUNTING.Frm_PhieuThu m_Frm_PhieuThu;
            public ACCOUNTING.Frm_PhieuThuList m_Frm_PhieuThuList;
            public ACCOUNTING.Frm_PhieuThuTien m_Frm_PhieuThuTien;
            public ACCOUNTING.Frm_PhuTungTaiSan m_Frm_PhuTungTaiSan;
            public ACCOUNTING.Frm_QuyenDuyetDonHang m_Frm_QuyenDuyetDonHang;
            public ACCOUNTING.Frm_QuyenNguoiSuDung m_Frm_QuyenNguoiSuDung;
            public ACCOUNTING.Frm_QuyenNhomNguoiDung m_Frm_QuyenNhomNguoiDung;
            public ACCOUNTING.Frm_RptBangCanDoiSoPhatSinh m_Frm_RptBangCanDoiSoPhatSinh;
            public ACCOUNTING.Frm_RptBangCanDoiTaiKhoan m_Frm_RptBangCanDoiTaiKhoan;
            public ACCOUNTING.Frm_RptBangGiaHangHoa m_Frm_RptBangGiaHangHoa;
            public ACCOUNTING.Frm_RptBangKeDoanhThuChiPHi m_Frm_RptBangKeDoanhThuChiPHi;
            public ACCOUNTING.Frm_RptBangKeHangHoaTonDuoiDinhMuc m_Frm_RptBangKeHangHoaTonDuoiDinhMuc;
            public ACCOUNTING.Frm_RptBangKeHangHoaTonKho m_Frm_RptBangKeHangHoaTonKho;
            public ACCOUNTING.Frm_RptBangKeHangHoaTraLai m_Frm_RptBangKeHangHoaTraLai;
            public ACCOUNTING.Frm_RptBangKeHoaDonNoThanhToan m_Frm_RptBangKeHoaDonNoThanhToan;
            public ACCOUNTING.Frm_RptBangKeHoaHong m_Frm_RptBangKeHoaHong;
            public ACCOUNTING.Frm_RptBangKePhieuChi m_Frm_RptBangKePhieuChi;
            public ACCOUNTING.Frm_RptBangKePhieuNhapKhau m_Frm_RptBangKePhieuNhapKhau;
            public ACCOUNTING.Frm_RptBangKePhieuNhapKho m_Frm_RptBangKePhieuNhapKho;
            public ACCOUNTING.Frm_RptBangKePhieuThu m_Frm_RptBangKePhieuThu;
            public ACCOUNTING.Frm_RptBangKePhieuXuatKho m_Frm_RptBangKePhieuXuatKho;
            public ACCOUNTING.Frm_RptBangKeThietBiSuaChua m_Frm_RptBangKeThietBiSuaChua;
            public ACCOUNTING.Frm_RptBangKeTraHangNhaCungCap m_Frm_RptBangKeTraHangNhaCungCap;
            public ACCOUNTING.Frm_RptBangTinhKhauHao m_Frm_RptBangTinhKhauHao;
            public ACCOUNTING.Frm_RptBaoCaoKyGoiDaiLy m_Frm_RptBaoCaoKyGoiDaiLy;
            public ACCOUNTING.Frm_RptChiPhiMuaHang m_Frm_RptChiPhiMuaHang;
            public ACCOUNTING.Frm_RptChiTietCongNo m_Frm_RptChiTietCongNo;
            public ACCOUNTING.Frm_RptCongNoChiTiet m_Frm_RptCongNoChiTiet;
            public ACCOUNTING.Frm_RptCongNoPhaiTra m_Frm_RptCongNoPhaiTra;
            public ACCOUNTING.Frm_RptDanhSachTaiSanCoDinh m_Frm_RptDanhSachTaiSanCoDinh;
            public ACCOUNTING.Frm_RptDoanhThuChiTiet m_Frm_RptDoanhThuChiTiet;
            public ACCOUNTING.Frm_RptDoanhThuTheoKhachHang m_Frm_RptDoanhThuTheoKhachHang;
            public ACCOUNTING.Frm_RptDoanhThuTheoKhuVuc m_Frm_RptDoanhThuTheoKhuVuc;
            public ACCOUNTING.Frm_RptDoanhThuTheoLoaiKH m_Frm_RptDoanhThuTheoLoaiKH;
            public ACCOUNTING.Frm_RptDoanhThuTheoMatHang m_Frm_RptDoanhThuTheoMatHang;
            public ACCOUNTING.Frm_RptDoanhThuTheoMatHangChiTiet m_Frm_RptDoanhThuTheoMatHangChiTiet;
            public ACCOUNTING.Frm_RptDoanhThuTheoNgay m_Frm_RptDoanhThuTheoNgay;
            public ACCOUNTING.Frm_RptDoanhThuTheoSanPham m_Frm_RptDoanhThuTheoSanPham;
            public ACCOUNTING.Frm_RptDoanhThuTongHop m_Frm_RptDoanhThuTongHop;
            public ACCOUNTING.Frm_RptDoiChieuCongNoPhaiThu m_Frm_RptDoiChieuCongNoPhaiThu;
            public ACCOUNTING.Frm_RptDoiChieuCongNoPhaiTra m_Frm_RptDoiChieuCongNoPhaiTra;
            public ACCOUNTING.Frm_RptHeHanSuDung m_Frm_RptHeHanSuDung;
            public ACCOUNTING.Frm_RptHoaDonBanDichVu m_Frm_RptHoaDonBanDichVu;
            public ACCOUNTING.Frm_RptHoaDonBanHang m_Frm_RptHoaDonBanHang;
            public ACCOUNTING.Frm_RptHoaDonBanHangCoChietKhau m_Frm_RptHoaDonBanHangCoChietKhau;
            public ACCOUNTING.Frm_RptHoaDonBanRa m_Frm_RptHoaDonBanRa;
            public ACCOUNTING.Frm_RptHoaDonChuaThanhToan m_Frm_RptHoaDonChuaThanhToan;
            public ACCOUNTING.Frm_RptHoaDonDenHanThanhToan m_Frm_RptHoaDonDenHanThanhToan;
            public ACCOUNTING.Frm_RptHoaDonMuaVao m_Frm_RptHoaDonMuaVao;
            public ACCOUNTING.Frm_RptHoaDonNoThanhToan m_Frm_RptHoaDonNoThanhToan;
            public ACCOUNTING.Frm_RptKetQuaHoatDongKinhDoanh m_Frm_RptKetQuaHoatDongKinhDoanh;
            public ACCOUNTING.Frm_RptKhachHangNoVuotDinhMuc m_Frm_RptKhachHangNoVuotDinhMuc;
            public ACCOUNTING.Frm_RptKhauHao m_Frm_RptKhauHao;
            public ACCOUNTING.Frm_RptLuuChuyenTien m_Frm_RptLuuChuyenTien;
            public ACCOUNTING.Frm_RptNhapXuatTonKho m_Frm_RptNhapXuatTonKho;
            public ACCOUNTING.Frm_RptQuaTrinhKhauHao m_Frm_RptQuaTrinhKhauHao;
            public ACCOUNTING.Frm_RptQuyTienGoiNganHang m_Frm_RptQuyTienGoiNganHang;
            public ACCOUNTING.Frm_RptQuyTienMat m_Frm_RptQuyTienMat;
            public ACCOUNTING.Frm_RptSoCaiChiTietTaiKhoan m_Frm_RptSoCaiChiTietTaiKhoan;
            public ACCOUNTING.Frm_RptSoCaiTaiKhoan m_Frm_RptSoCaiTaiKhoan;
            public ACCOUNTING.Frm_RptSoNhatKyBanHang m_Frm_RptSoNhatKyBanHang;
            public ACCOUNTING.Frm_RptSoNhatKyChiTien m_Frm_RptSoNhatKyChiTien;
            public ACCOUNTING.Frm_RptSoNhatKyMuaHang m_Frm_RptSoNhatKyMuaHang;
            public ACCOUNTING.Frm_RptSoNhatKyThuTien m_Frm_RptSoNhatKyThuTien;
            public ACCOUNTING.Frm_RptThueNhapKhauDenHanNop m_Frm_RptThueNhapKhauDenHanNop;
            public ACCOUNTING.Frm_RptThuyetMinhChiPhi m_Frm_RptThuyetMinhChiPhi;
            public ACCOUNTING.Frm_RptTongHopHangHoaMuaVao m_Frm_RptTongHopHangHoaMuaVao;
            public ACCOUNTING.Frm_RptXuatChuyenKhoList m_Frm_RptXuatChuyenKhoList;
            public ACCOUNTING.Frm_Run m_Frm_Run;
            public ACCOUNTING.Frm_RunSQL m_Frm_RunSQL;
            public ACCOUNTING.Frm_SaleOrder m_Frm_SaleOrder;
            public ACCOUNTING.Frm_SanPhamDoDang m_Frm_SanPhamDoDang;
            public ACCOUNTING.Frm_SearchTaiSanCoDinh m_Frm_SearchTaiSanCoDinh;
            public ACCOUNTING.Frm_SoCaiChiTietTaiKhoan m_Frm_SoCaiChiTietTaiKhoan;
            public ACCOUNTING.Frm_SoDuDauKy m_Frm_SoDuDauKy;
            public ACCOUNTING.Frm_SoDuDauKyCongNo m_Frm_SoDuDauKyCongNo;
            public ACCOUNTING.Frm_SoDuDauKyHangHoa m_Frm_SoDuDauKyHangHoa;
            public ACCOUNTING.Frm_SoDuDauKyTaiSan m_Frm_SoDuDauKyTaiSan;
            public ACCOUNTING.Frm_SoNhatKyChung m_Frm_SoNhatKyChung;
            public ACCOUNTING.Frm_SoSuaChua m_Frm_SoSuaChua;
            public ACCOUNTING.Frm_SplashScreen m_Frm_SplashScreen;
            public ACCOUNTING.Frm_TaiKhoanChiPhiTraTruoc m_Frm_TaiKhoanChiPhiTraTruoc;
            public ACCOUNTING.Frm_TaiSan m_Frm_TaiSan;
            public ACCOUNTING.Frm_TamUng m_Frm_TamUng;
            public ACCOUNTING.Frm_TangTaiSan m_Frm_TangTaiSan;
            public ACCOUNTING.Frm_TangTaiSanList m_Frm_TangTaiSanList;
            public ACCOUNTING.Frm_TaoDuLieuMoi m_Frm_TaoDuLieuMoi;
            public ACCOUNTING.Frm_ThanhToan m_Frm_ThanhToan;
            public ACCOUNTING.Frm_ThanhToanDauVao m_Frm_ThanhToanDauVao;
            public ACCOUNTING.Frm_ThanhToanNhaCungCap m_Frm_ThanhToanNhaCungCap;
            public ACCOUNTING.Frm_ThanhToanNhaCungCapList m_Frm_ThanhToanNhaCungCapList;
            public ACCOUNTING.Frm_TheKhoVatTu m_Frm_TheKhoVatTu;
            public ACCOUNTING.Frm_ThemKiHieu m_Frm_ThemKiHieu;
            public ACCOUNTING.Frm_ThietLapHoaDon m_Frm_ThietLapHoaDon;
            public ACCOUNTING.Frm_ThongSo m_Frm_ThongSo;
            public ACCOUNTING.Frm_ThongTinCongTy m_Frm_ThongTinCongTy;
            public ACCOUNTING.Frm_ThongTinPhanMem m_Frm_ThongTinPhanMem;
            public ACCOUNTING.Frm_ThongTinThemChuyenDiaDiem m_Frm_ThongTinThemChuyenDiaDiem;
            public ACCOUNTING.Frm_ThongTinThemPhatHanhHoaDon m_Frm_ThongTinThemPhatHanhHoaDon;
            public ACCOUNTING.Frm_ThuTienBanHangList m_Frm_ThuTienBanHangList;
            public ACCOUNTING.Frm_TiepNhanList m_Frm_TiepNhanList;
            public ACCOUNTING.Frm_TiepNhanThietBi m_Frm_TiepNhanThietBi;
            public ACCOUNTING.Frm_TimDanhMuc m_Frm_TimDanhMuc;
            public ACCOUNTING.Frm_TimDoiTuong m_Frm_TimDoiTuong;
            public ACCOUNTING.Frm_TimHangHoa m_Frm_TimHangHoa;
            public ACCOUNTING.Frm_TimThanhPham m_Frm_TimThanhPham;
            public ACCOUNTING.Frm_TimHangTonKho m_Frm_TimHangTonKho;
            public ACCOUNTING.Frm_TimPhieuBanHang m_Frm_TimPhieuBanHang;
            public ACCOUNTING.Frm_TimPhieuChiTienThua m_Frm_TimPhieuChiTienThua;
            public ACCOUNTING.Frm_TimPhieuMuaHangNuocNgoai m_Frm_TimPhieuMuaHangNuocNgoai;
            public ACCOUNTING.Frm_TimPhieuMuaHangTrongNuoc m_Frm_TimPhieuMuaHangTrongNuoc;
            public ACCOUNTING.Frm_TimPhieuThuTienThua m_Frm_TimPhieuThuTienThua;
            public ACCOUNTING.Frm_TimQuocGia m_Frm_TimQuocGia;
            public ACCOUNTING.Frm_TinhChiPhiBanHang m_Frm_TinhChiPhiBanHang;
            public ACCOUNTING.Frm_TinhHoaHong m_Frm_TinhHoaHong;
            public ACCOUNTING.Frm_TongHop m_Frm_TongHop;
            public ACCOUNTING.Frm_TongHopHangTonKho m_Frm_TongHopHangTonKho;
            public ACCOUNTING.Frm_TongHopList m_Frm_TongHopList;
            public ACCOUNTING.Frm_TongHopThanhToanTienHang m_Frm_TongHopThanhToanTienHang;
            public ACCOUNTING.Frm_TongHopThuTienBanHang m_Frm_TongHopThuTienBanHang;
            public ACCOUNTING.Frm_TraCuuQuaTrinhNhapXuat m_Frm_TraCuuQuaTrinhNhapXuat;
            public ACCOUNTING.Frm_TraHangNhaCungCap m_Frm_TraHangNhaCungCap;
            public ACCOUNTING.Frm_TraHangNhaCungCapList m_Frm_TraHangNhaCungCapList;
            public ACCOUNTING.Frm_TranferData m_Frm_TranferData;
            public ACCOUNTING.Frm_TraTruocNguoiBan m_Frm_TraTruocNguoiBan;
            public ACCOUNTING.Frm_TraTruocNguoiBanList m_Frm_TraTruocNguoiBanList;
            public ACCOUNTING.Frm_TruyVanBanHang m_Frm_TruyVanBanHang;
            public ACCOUNTING.Frm_TruyVanCongNoPhaiThu m_Frm_TruyVanCongNoPhaiThu;
            public ACCOUNTING.Frm_TruyVanCongNoPhaiTra m_Frm_TruyVanCongNoPhaiTra;
            public ACCOUNTING.Frm_TruyVanHangTonKho m_Frm_TruyVanHangTonKho;
            public ACCOUNTING.Frm_TSCD m_Frm_TSCD;
            public ACCOUNTING.Frm_TuyChonInBaoGia m_Frm_TuyChonInBaoGia;
            public ACCOUNTING.Frm_ViewReport m_Frm_ViewReport;
            public ACCOUNTING.Frm_ViewReport2 m_Frm_ViewReport2;
            public ACCOUNTING.Frm_VonBangTien m_Frm_VonBangTien;
            public ACCOUNTING.Frm_XacDinhSanPhanHoanThanh m_Frm_XacDinhSanPhanHoanThanh;
            public ACCOUNTING.Frm_XacNhanDonHang m_Frm_XacNhanDonHang;
            public ACCOUNTING.Frm_XacNhanDonHangBan m_Frm_XacNhanDonHangBan;
            public ACCOUNTING.Frm_XacNhanThanhToanDauVao m_Frm_XacNhanThanhToanDauVao;
            public ACCOUNTING.Frm_XacNhanThanhToanHoaDon m_Frm_XacNhanThanhToanHoaDon;
            public ACCOUNTING.Frm_XemDinhKhoan m_Frm_XemDinhKhoan;
            public ACCOUNTING.Frm_XuatBan m_Frm_XuatBan;
            public ACCOUNTING.Frm_XuatBanList m_Frm_XuatBanList;
            public ACCOUNTING.Frm_XuatChuyen m_Frm_XuatChuyen;
            public ACCOUNTING.Frm_XuatChuyenKhoList m_Frm_XuatChuyenKhoList;
            public ACCOUNTING.Frm_XuatKho m_Frm_XuatKho;
            public ACCOUNTING.Frm_XuatKhoList m_Frm_XuatKhoList;
            public ACCOUNTING.Frm_YeuCauBaoGia m_Frm_YeuCauBaoGia;
            public ACCOUNTING.FRMMAIN m_FRMMAIN;
            public ACCOUNTING.FrmTimKhachHangTamUng m_FrmTimKhachHangTamUng;
            public ACCOUNTING.FrmTimTraTruocNguoiBan m_FrmTimTraTruocNguoiBan;
            public ACCOUNTING.MultiColumnDropDown m_MultiColumnDropDown;
            public ACCOUNTING.PopupDropDown m_PopupDropDown;
            public ACCOUNTING.Frm_Test m_Frm_Test;
            public ACCOUNTING.Frm_00TestParentChild m_Frm_00TestParentChild;
            public ACCOUNTING.Frm_DMDTTHCPList m_Frm_DMDTTHCPList;


            [DebuggerHidden]
            private static T Create__Instance__<T>(T Instance) where T: Form, new()
            {
                T local;
                if ((((Instance == null) || Instance.IsDisposed) ? 1 : 0) == 0)
                {
                    return Instance;
                }
                if (m_FormBeingCreated != null)
                {
                    if (m_FormBeingCreated.ContainsKey(typeof(T)))
                    {
                        throw new InvalidOperationException(Utils.GetResourceString("WinForms_RecursiveFormCreate", new string[0]));
                    }
                }
                else
                {
                    m_FormBeingCreated = new Hashtable();
                }
                m_FormBeingCreated.Add(typeof(T), null);
                try
                {
                    return Activator.CreateInstance<T>();
                }
                catch (Exception exception)
                {
                    //TargetInvocationException exception;
                    throw new InvalidOperationException(Utils.GetResourceString("WinForms_SeeInnerException", new string[] { exception.InnerException.Message }), exception.InnerException);
                    ProjectData.ClearProjectError();
                }
                finally
                {
                    m_FormBeingCreated.Remove(typeof(T));
                }
                return local;
            }

            [DebuggerHidden]
            private void Dispose__Instance__<T>(ref T instance) where T: Form
            {
                instance.Dispose();
                instance = default(T);
            }

            [EditorBrowsable(EditorBrowsableState.Never)]
            public override bool Equals(object o)
            {
                return base.Equals(RuntimeHelpers.GetObjectValue(o));
            }

            [EditorBrowsable(EditorBrowsableState.Never)]
            public override int GetHashCode()
            {
                return base.GetHashCode();
            }

            [EditorBrowsable(EditorBrowsableState.Never)]
            internal Type GetType()
            {
                return typeof(MyProject.MyForms);
            }

            [EditorBrowsable(EditorBrowsableState.Never)]
            public override string ToString()
            {
                return base.ToString();
            }
            public ACCOUNTING.Frm_Test Frm_Test
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_Test = Create__Instance__<ACCOUNTING.Frm_Test>(this.m_Frm_Test);
                    return this.m_Frm_Test;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_Test)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_Test>(ref this.m_Frm_Test);
                    }
                }
            }
            public ACCOUNTING.Frm_00TestParentChild Frm_00TestParentChild
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_00TestParentChild = Create__Instance__<ACCOUNTING.Frm_00TestParentChild>(this.m_Frm_00TestParentChild);
                    return this.m_Frm_00TestParentChild;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_00TestParentChild)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_00TestParentChild>(ref this.m_Frm_00TestParentChild);
                    }
                }
            }
            public ACCOUNTING.Frm_DMDTTHCPList Frm_DMDTTHCPList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMDTTHCPList = Create__Instance__<ACCOUNTING.Frm_DMDTTHCPList>(this.m_Frm_DMDTTHCPList);
                    return this.m_Frm_DMDTTHCPList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMDTTHCPList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMDTTHCPList>(ref this.m_Frm_DMDTTHCPList);
                    }
                }
            }

            public ACCOUNTING.Frm_AddDonViTinh Frm_AddDonViTinh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_AddDonViTinh = Create__Instance__<ACCOUNTING.Frm_AddDonViTinh>(this.m_Frm_AddDonViTinh);
                    return this.m_Frm_AddDonViTinh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_AddDonViTinh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_AddDonViTinh>(ref this.m_Frm_AddDonViTinh);
                    }
                }
            }

            public ACCOUNTING.Frm_AddHoaDonBanHang Frm_AddHoaDonBanHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_AddHoaDonBanHang = Create__Instance__<ACCOUNTING.Frm_AddHoaDonBanHang>(this.m_Frm_AddHoaDonBanHang);
                    return this.m_Frm_AddHoaDonBanHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_AddHoaDonBanHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_AddHoaDonBanHang>(ref this.m_Frm_AddHoaDonBanHang);
                    }
                }
            }

            public ACCOUNTING.Frm_AddThanhToanMuaHang Frm_AddThanhToanMuaHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_AddThanhToanMuaHang = Create__Instance__<ACCOUNTING.Frm_AddThanhToanMuaHang>(this.m_Frm_AddThanhToanMuaHang);
                    return this.m_Frm_AddThanhToanMuaHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_AddThanhToanMuaHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_AddThanhToanMuaHang>(ref this.m_Frm_AddThanhToanMuaHang);
                    }
                }
            }

            public ACCOUNTING.Frm_BanGiaoSuaChua Frm_BanGiaoSuaChua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BanGiaoSuaChua = Create__Instance__<ACCOUNTING.Frm_BanGiaoSuaChua>(this.m_Frm_BanGiaoSuaChua);
                    return this.m_Frm_BanGiaoSuaChua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BanGiaoSuaChua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BanGiaoSuaChua>(ref this.m_Frm_BanGiaoSuaChua);
                    }
                }
            }

            public ACCOUNTING.Frm_BangKeHoaDonMuaDichVu Frm_BangKeHoaDonMuaDichVu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BangKeHoaDonMuaDichVu = Create__Instance__<ACCOUNTING.Frm_BangKeHoaDonMuaDichVu>(this.m_Frm_BangKeHoaDonMuaDichVu);
                    return this.m_Frm_BangKeHoaDonMuaDichVu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BangKeHoaDonMuaDichVu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BangKeHoaDonMuaDichVu>(ref this.m_Frm_BangKeHoaDonMuaDichVu);
                    }
                }
            }

            public ACCOUNTING.Frm_BanHang Frm_BanHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BanHang = Create__Instance__<ACCOUNTING.Frm_BanHang>(this.m_Frm_BanHang);
                    return this.m_Frm_BanHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BanHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BanHang>(ref this.m_Frm_BanHang);
                    }
                }
            }

            public ACCOUNTING.Frm_BaoCaoDoanhThuTheoNhanVien Frm_BaoCaoDoanhThuTheoNhanVien
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BaoCaoDoanhThuTheoNhanVien = Create__Instance__<ACCOUNTING.Frm_BaoCaoDoanhThuTheoNhanVien>(this.m_Frm_BaoCaoDoanhThuTheoNhanVien);
                    return this.m_Frm_BaoCaoDoanhThuTheoNhanVien;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BaoCaoDoanhThuTheoNhanVien)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BaoCaoDoanhThuTheoNhanVien>(ref this.m_Frm_BaoCaoDoanhThuTheoNhanVien);
                    }
                }
            }

            public ACCOUNTING.Frm_BaoCoNganHang Frm_BaoCoNganHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BaoCoNganHang = Create__Instance__<ACCOUNTING.Frm_BaoCoNganHang>(this.m_Frm_BaoCoNganHang);
                    return this.m_Frm_BaoCoNganHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BaoCoNganHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BaoCoNganHang>(ref this.m_Frm_BaoCoNganHang);
                    }
                }
            }

            public ACCOUNTING.Frm_BaoCoNganHangList Frm_BaoCoNganHangList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BaoCoNganHangList = Create__Instance__<ACCOUNTING.Frm_BaoCoNganHangList>(this.m_Frm_BaoCoNganHangList);
                    return this.m_Frm_BaoCoNganHangList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BaoCoNganHangList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BaoCoNganHangList>(ref this.m_Frm_BaoCoNganHangList);
                    }
                }
            }

            public ACCOUNTING.Frm_BaoGia Frm_BaoGia
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BaoGia = Create__Instance__<ACCOUNTING.Frm_BaoGia>(this.m_Frm_BaoGia);
                    return this.m_Frm_BaoGia;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BaoGia)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BaoGia>(ref this.m_Frm_BaoGia);
                    }
                }
            }

            public ACCOUNTING.Frm_BaoGiaList Frm_BaoGiaList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BaoGiaList = Create__Instance__<ACCOUNTING.Frm_BaoGiaList>(this.m_Frm_BaoGiaList);
                    return this.m_Frm_BaoGiaList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BaoGiaList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BaoGiaList>(ref this.m_Frm_BaoGiaList);
                    }
                }
            }

            public ACCOUNTING.Frm_BaoNoNganHang Frm_BaoNoNganHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BaoNoNganHang = Create__Instance__<ACCOUNTING.Frm_BaoNoNganHang>(this.m_Frm_BaoNoNganHang);
                    return this.m_Frm_BaoNoNganHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BaoNoNganHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BaoNoNganHang>(ref this.m_Frm_BaoNoNganHang);
                    }
                }
            }

            public ACCOUNTING.Frm_BaoNoNganHangList Frm_BaoNoNganHangList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BaoNoNganHangList = Create__Instance__<ACCOUNTING.Frm_BaoNoNganHangList>(this.m_Frm_BaoNoNganHangList);
                    return this.m_Frm_BaoNoNganHangList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BaoNoNganHangList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BaoNoNganHangList>(ref this.m_Frm_BaoNoNganHangList);
                    }
                }
            }

            public ACCOUNTING.Frm_BCPhatHanhHoaDon Frm_BCPhatHanhHoaDon
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BCPhatHanhHoaDon = Create__Instance__<ACCOUNTING.Frm_BCPhatHanhHoaDon>(this.m_Frm_BCPhatHanhHoaDon);
                    return this.m_Frm_BCPhatHanhHoaDon;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BCPhatHanhHoaDon)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BCPhatHanhHoaDon>(ref this.m_Frm_BCPhatHanhHoaDon);
                    }
                }
            }

            public ACCOUNTING.Frm_BCTinhHinhSuDungHoaDon Frm_BCTinhHinhSuDungHoaDon
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_BCTinhHinhSuDungHoaDon = Create__Instance__<ACCOUNTING.Frm_BCTinhHinhSuDungHoaDon>(this.m_Frm_BCTinhHinhSuDungHoaDon);
                    return this.m_Frm_BCTinhHinhSuDungHoaDon;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_BCTinhHinhSuDungHoaDon)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_BCTinhHinhSuDungHoaDon>(ref this.m_Frm_BCTinhHinhSuDungHoaDon);
                    }
                }
            }

            public ACCOUNTING.Frm_CanhBaoHangTonKho Frm_CanhBaoHangTonKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CanhBaoHangTonKho = Create__Instance__<ACCOUNTING.Frm_CanhBaoHangTonKho>(this.m_Frm_CanhBaoHangTonKho);
                    return this.m_Frm_CanhBaoHangTonKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CanhBaoHangTonKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CanhBaoHangTonKho>(ref this.m_Frm_CanhBaoHangTonKho);
                    }
                }
            }

            public ACCOUNTING.Frm_CanTruCongNo Frm_CanTruCongNo
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CanTruCongNo = Create__Instance__<ACCOUNTING.Frm_CanTruCongNo>(this.m_Frm_CanTruCongNo);
                    return this.m_Frm_CanTruCongNo;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CanTruCongNo)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CanTruCongNo>(ref this.m_Frm_CanTruCongNo);
                    }
                }
            }

            public ACCOUNTING.Frm_CanTruCongNoList Frm_CanTruCongNoList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CanTruCongNoList = Create__Instance__<ACCOUNTING.Frm_CanTruCongNoList>(this.m_Frm_CanTruCongNoList);
                    return this.m_Frm_CanTruCongNoList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CanTruCongNoList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CanTruCongNoList>(ref this.m_Frm_CanTruCongNoList);
                    }
                }
            }

            public ACCOUNTING.Frm_CapNhatDienGiai Frm_CapNhatDienGiai
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CapNhatDienGiai = Create__Instance__<ACCOUNTING.Frm_CapNhatDienGiai>(this.m_Frm_CapNhatDienGiai);
                    return this.m_Frm_CapNhatDienGiai;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CapNhatDienGiai)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CapNhatDienGiai>(ref this.m_Frm_CapNhatDienGiai);
                    }
                }
            }

            public ACCOUNTING.Frm_CapNhatGiaBan Frm_CapNhatGiaBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CapNhatGiaBan = Create__Instance__<ACCOUNTING.Frm_CapNhatGiaBan>(this.m_Frm_CapNhatGiaBan);
                    return this.m_Frm_CapNhatGiaBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CapNhatGiaBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CapNhatGiaBan>(ref this.m_Frm_CapNhatGiaBan);
                    }
                }
            }

            public ACCOUNTING.Frm_CapNhatGiaMua Frm_CapNhatGiaMua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CapNhatGiaMua = Create__Instance__<ACCOUNTING.Frm_CapNhatGiaMua>(this.m_Frm_CapNhatGiaMua);
                    return this.m_Frm_CapNhatGiaMua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CapNhatGiaMua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CapNhatGiaMua>(ref this.m_Frm_CapNhatGiaMua);
                    }
                }
            }

            public ACCOUNTING.Frm_CapNhatGiaVonXuatKho Frm_CapNhatGiaVonXuatKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CapNhatGiaVonXuatKho = Create__Instance__<ACCOUNTING.Frm_CapNhatGiaVonXuatKho>(this.m_Frm_CapNhatGiaVonXuatKho);
                    return this.m_Frm_CapNhatGiaVonXuatKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CapNhatGiaVonXuatKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CapNhatGiaVonXuatKho>(ref this.m_Frm_CapNhatGiaVonXuatKho);
                    }
                }
            }

            public ACCOUNTING.Frm_CapNhatSoDuDauKyHangHoaTheoLo Frm_CapNhatSoDuDauKyHangHoaTheoLo
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CapNhatSoDuDauKyHangHoaTheoLo = Create__Instance__<ACCOUNTING.Frm_CapNhatSoDuDauKyHangHoaTheoLo>(this.m_Frm_CapNhatSoDuDauKyHangHoaTheoLo);
                    return this.m_Frm_CapNhatSoDuDauKyHangHoaTheoLo;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CapNhatSoDuDauKyHangHoaTheoLo)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CapNhatSoDuDauKyHangHoaTheoLo>(ref this.m_Frm_CapNhatSoDuDauKyHangHoaTheoLo);
                    }
                }
            }

            public ACCOUNTING.Frm_CapNhatSoDuDauKyTaiKhoan Frm_CapNhatSoDuDauKyTaiKhoan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CapNhatSoDuDauKyTaiKhoan = Create__Instance__<ACCOUNTING.Frm_CapNhatSoDuDauKyTaiKhoan>(this.m_Frm_CapNhatSoDuDauKyTaiKhoan);
                    return this.m_Frm_CapNhatSoDuDauKyTaiKhoan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CapNhatSoDuDauKyTaiKhoan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CapNhatSoDuDauKyTaiKhoan>(ref this.m_Frm_CapNhatSoDuDauKyTaiKhoan);
                    }
                }
            }

            public ACCOUNTING.Frm_CapNhatSoDuHangHoa Frm_CapNhatSoDuHangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CapNhatSoDuHangHoa = Create__Instance__<ACCOUNTING.Frm_CapNhatSoDuHangHoa>(this.m_Frm_CapNhatSoDuHangHoa);
                    return this.m_Frm_CapNhatSoDuHangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CapNhatSoDuHangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CapNhatSoDuHangHoa>(ref this.m_Frm_CapNhatSoDuHangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_ChiPhiMuaHang Frm_ChiPhiMuaHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ChiPhiMuaHang = Create__Instance__<ACCOUNTING.Frm_ChiPhiMuaHang>(this.m_Frm_ChiPhiMuaHang);
                    return this.m_Frm_ChiPhiMuaHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ChiPhiMuaHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ChiPhiMuaHang>(ref this.m_Frm_ChiPhiMuaHang);
                    }
                }
            }

            public ACCOUNTING.Frm_ChiPhiMuaHangList Frm_ChiPhiMuaHangList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ChiPhiMuaHangList = Create__Instance__<ACCOUNTING.Frm_ChiPhiMuaHangList>(this.m_Frm_ChiPhiMuaHangList);
                    return this.m_Frm_ChiPhiMuaHangList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ChiPhiMuaHangList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ChiPhiMuaHangList>(ref this.m_Frm_ChiPhiMuaHangList);
                    }
                }
            }

            public ACCOUNTING.Frm_ChiPhiTraTruoc Frm_ChiPhiTraTruoc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ChiPhiTraTruoc = Create__Instance__<ACCOUNTING.Frm_ChiPhiTraTruoc>(this.m_Frm_ChiPhiTraTruoc);
                    return this.m_Frm_ChiPhiTraTruoc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ChiPhiTraTruoc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ChiPhiTraTruoc>(ref this.m_Frm_ChiPhiTraTruoc);
                    }
                }
            }

            public ACCOUNTING.Frm_ChonHangTraLai Frm_ChonHangTraLai
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ChonHangTraLai = Create__Instance__<ACCOUNTING.Frm_ChonHangTraLai>(this.m_Frm_ChonHangTraLai);
                    return this.m_Frm_ChonHangTraLai;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ChonHangTraLai)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ChonHangTraLai>(ref this.m_Frm_ChonHangTraLai);
                    }
                }
            }

            public ACCOUNTING.Frm_ChonHangTuGiaoHang Frm_ChonHangTuGiaoHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ChonHangTuGiaoHang = Create__Instance__<ACCOUNTING.Frm_ChonHangTuGiaoHang>(this.m_Frm_ChonHangTuGiaoHang);
                    return this.m_Frm_ChonHangTuGiaoHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ChonHangTuGiaoHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ChonHangTuGiaoHang>(ref this.m_Frm_ChonHangTuGiaoHang);
                    }
                }
            }

            public ACCOUNTING.Frm_ChungTuTongHop Frm_ChungTuTongHop
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ChungTuTongHop = Create__Instance__<ACCOUNTING.Frm_ChungTuTongHop>(this.m_Frm_ChungTuTongHop);
                    return this.m_Frm_ChungTuTongHop;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ChungTuTongHop)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ChungTuTongHop>(ref this.m_Frm_ChungTuTongHop);
                    }
                }
            }

            public ACCOUNTING.Frm_ChungTuTongHopList Frm_ChungTuTongHopList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ChungTuTongHopList = Create__Instance__<ACCOUNTING.Frm_ChungTuTongHopList>(this.m_Frm_ChungTuTongHopList);
                    return this.m_Frm_ChungTuTongHopList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ChungTuTongHopList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ChungTuTongHopList>(ref this.m_Frm_ChungTuTongHopList);
                    }
                }
            }

            public ACCOUNTING.Frm_ChuyenDuLieuDanhMucSangChiNhanh Frm_ChuyenDuLieuDanhMucSangChiNhanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ChuyenDuLieuDanhMucSangChiNhanh = Create__Instance__<ACCOUNTING.Frm_ChuyenDuLieuDanhMucSangChiNhanh>(this.m_Frm_ChuyenDuLieuDanhMucSangChiNhanh);
                    return this.m_Frm_ChuyenDuLieuDanhMucSangChiNhanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ChuyenDuLieuDanhMucSangChiNhanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ChuyenDuLieuDanhMucSangChiNhanh>(ref this.m_Frm_ChuyenDuLieuDanhMucSangChiNhanh);
                    }
                }
            }

            public ACCOUNTING.Frm_ClearData Frm_ClearData
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ClearData = Create__Instance__<ACCOUNTING.Frm_ClearData>(this.m_Frm_ClearData);
                    return this.m_Frm_ClearData;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ClearData)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ClearData>(ref this.m_Frm_ClearData);
                    }
                }
            }

            public ACCOUNTING.Frm_CongNoPhaiThu Frm_CongNoPhaiThu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_CongNoPhaiThu = Create__Instance__<ACCOUNTING.Frm_CongNoPhaiThu>(this.m_Frm_CongNoPhaiThu);
                    return this.m_Frm_CongNoPhaiThu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_CongNoPhaiThu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_CongNoPhaiThu>(ref this.m_Frm_CongNoPhaiThu);
                    }
                }
            }

            public ACCOUNTING.Frm_DangKyBanQuyen Frm_DangKyBanQuyen
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DangKyBanQuyen = Create__Instance__<ACCOUNTING.Frm_DangKyBanQuyen>(this.m_Frm_DangKyBanQuyen);
                    return this.m_Frm_DangKyBanQuyen;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DangKyBanQuyen)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DangKyBanQuyen>(ref this.m_Frm_DangKyBanQuyen);
                    }
                }
            }

            public ACCOUNTING.Frm_DangKyDuLieu Frm_DangKyDuLieu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DangKyDuLieu = Create__Instance__<ACCOUNTING.Frm_DangKyDuLieu>(this.m_Frm_DangKyDuLieu);
                    return this.m_Frm_DangKyDuLieu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DangKyDuLieu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DangKyDuLieu>(ref this.m_Frm_DangKyDuLieu);
                    }
                }
            }

            public ACCOUNTING.Frm_DangKyHoaDon Frm_DangKyHoaDon
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DangKyHoaDon = Create__Instance__<ACCOUNTING.Frm_DangKyHoaDon>(this.m_Frm_DangKyHoaDon);
                    return this.m_Frm_DangKyHoaDon;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DangKyHoaDon)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DangKyHoaDon>(ref this.m_Frm_DangKyHoaDon);
                    }
                }
            }

            public ACCOUNTING.Frm_DangKyHoaDonList Frm_DangKyHoaDonList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DangKyHoaDonList = Create__Instance__<ACCOUNTING.Frm_DangKyHoaDonList>(this.m_Frm_DangKyHoaDonList);
                    return this.m_Frm_DangKyHoaDonList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DangKyHoaDonList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DangKyHoaDonList>(ref this.m_Frm_DangKyHoaDonList);
                    }
                }
            }

            public ACCOUNTING.Frm_DanhSachHoaDonHuy Frm_DanhSachHoaDonHuy
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DanhSachHoaDonHuy = Create__Instance__<ACCOUNTING.Frm_DanhSachHoaDonHuy>(this.m_Frm_DanhSachHoaDonHuy);
                    return this.m_Frm_DanhSachHoaDonHuy;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DanhSachHoaDonHuy)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DanhSachHoaDonHuy>(ref this.m_Frm_DanhSachHoaDonHuy);
                    }
                }
            }

            public ACCOUNTING.Frm_DanhSachNguoiDung Frm_DanhSachNguoiDung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DanhSachNguoiDung = Create__Instance__<ACCOUNTING.Frm_DanhSachNguoiDung>(this.m_Frm_DanhSachNguoiDung);
                    return this.m_Frm_DanhSachNguoiDung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DanhSachNguoiDung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DanhSachNguoiDung>(ref this.m_Frm_DanhSachNguoiDung);
                    }
                }
            }

            public ACCOUNTING.Frm_DanhSachSanPhamDoDang Frm_DanhSachSanPhamDoDang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DanhSachSanPhamDoDang = Create__Instance__<ACCOUNTING.Frm_DanhSachSanPhamDoDang>(this.m_Frm_DanhSachSanPhamDoDang);
                    return this.m_Frm_DanhSachSanPhamDoDang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DanhSachSanPhamDoDang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DanhSachSanPhamDoDang>(ref this.m_Frm_DanhSachSanPhamDoDang);
                    }
                }
            }

            public ACCOUNTING.Frm_DanhSachTaiSanCoDinh Frm_DanhSachTaiSanCoDinh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DanhSachTaiSanCoDinh = Create__Instance__<ACCOUNTING.Frm_DanhSachTaiSanCoDinh>(this.m_Frm_DanhSachTaiSanCoDinh);
                    return this.m_Frm_DanhSachTaiSanCoDinh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DanhSachTaiSanCoDinh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DanhSachTaiSanCoDinh>(ref this.m_Frm_DanhSachTaiSanCoDinh);
                    }
                }
            }

            public ACCOUNTING.Frm_DanhSachXacNhanDonHang Frm_DanhSachXacNhanDonHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DanhSachXacNhanDonHang = Create__Instance__<ACCOUNTING.Frm_DanhSachXacNhanDonHang>(this.m_Frm_DanhSachXacNhanDonHang);
                    return this.m_Frm_DanhSachXacNhanDonHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DanhSachXacNhanDonHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DanhSachXacNhanDonHang>(ref this.m_Frm_DanhSachXacNhanDonHang);
                    }
                }
            }

            public ACCOUNTING.Frm_DatabaseChiNhanh Frm_DatabaseChiNhanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DatabaseChiNhanh = Create__Instance__<ACCOUNTING.Frm_DatabaseChiNhanh>(this.m_Frm_DatabaseChiNhanh);
                    return this.m_Frm_DatabaseChiNhanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DatabaseChiNhanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DatabaseChiNhanh>(ref this.m_Frm_DatabaseChiNhanh);
                    }
                }
            }

            public ACCOUNTING.Frm_Dictionary Frm_Dictionary
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_Dictionary = Create__Instance__<ACCOUNTING.Frm_Dictionary>(this.m_Frm_Dictionary);
                    return this.m_Frm_Dictionary;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_Dictionary)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_Dictionary>(ref this.m_Frm_Dictionary);
                    }
                }
            }

            public ACCOUNTING.Frm_DieuKhoanBaoGia Frm_DieuKhoanBaoGia
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DieuKhoanBaoGia = Create__Instance__<ACCOUNTING.Frm_DieuKhoanBaoGia>(this.m_Frm_DieuKhoanBaoGia);
                    return this.m_Frm_DieuKhoanBaoGia;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DieuKhoanBaoGia)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DieuKhoanBaoGia>(ref this.m_Frm_DieuKhoanBaoGia);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhKhoanNhapKhau Frm_DinhKhoanNhapKhau
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhKhoanNhapKhau = Create__Instance__<ACCOUNTING.Frm_DinhKhoanNhapKhau>(this.m_Frm_DinhKhoanNhapKhau);
                    return this.m_Frm_DinhKhoanNhapKhau;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhKhoanNhapKhau)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhKhoanNhapKhau>(ref this.m_Frm_DinhKhoanNhapKhau);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhKhoanPhieuNhapKho Frm_DinhKhoanPhieuNhapKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhKhoanPhieuNhapKho = Create__Instance__<ACCOUNTING.Frm_DinhKhoanPhieuNhapKho>(this.m_Frm_DinhKhoanPhieuNhapKho);
                    return this.m_Frm_DinhKhoanPhieuNhapKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhKhoanPhieuNhapKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhKhoanPhieuNhapKho>(ref this.m_Frm_DinhKhoanPhieuNhapKho);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhKhoanTraHang Frm_DinhKhoanTraHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhKhoanTraHang = Create__Instance__<ACCOUNTING.Frm_DinhKhoanTraHang>(this.m_Frm_DinhKhoanTraHang);
                    return this.m_Frm_DinhKhoanTraHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhKhoanTraHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhKhoanTraHang>(ref this.m_Frm_DinhKhoanTraHang);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhKhoanXuatBan Frm_DinhKhoanXuatBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhKhoanXuatBan = Create__Instance__<ACCOUNTING.Frm_DinhKhoanXuatBan>(this.m_Frm_DinhKhoanXuatBan);
                    return this.m_Frm_DinhKhoanXuatBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhKhoanXuatBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhKhoanXuatBan>(ref this.m_Frm_DinhKhoanXuatBan);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhNghiaCanDoiKeToan Frm_DinhNghiaCanDoiKeToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhNghiaCanDoiKeToan = Create__Instance__<ACCOUNTING.Frm_DinhNghiaCanDoiKeToan>(this.m_Frm_DinhNghiaCanDoiKeToan);
                    return this.m_Frm_DinhNghiaCanDoiKeToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhNghiaCanDoiKeToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhNghiaCanDoiKeToan>(ref this.m_Frm_DinhNghiaCanDoiKeToan);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhNghiaChiNhanh Frm_DinhNghiaChiNhanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhNghiaChiNhanh = Create__Instance__<ACCOUNTING.Frm_DinhNghiaChiNhanh>(this.m_Frm_DinhNghiaChiNhanh);
                    return this.m_Frm_DinhNghiaChiNhanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhNghiaChiNhanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhNghiaChiNhanh>(ref this.m_Frm_DinhNghiaChiNhanh);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhNghiaKetChuyenChiPhiTraTruoc Frm_DinhNghiaKetChuyenChiPhiTraTruoc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhNghiaKetChuyenChiPhiTraTruoc = Create__Instance__<ACCOUNTING.Frm_DinhNghiaKetChuyenChiPhiTraTruoc>(this.m_Frm_DinhNghiaKetChuyenChiPhiTraTruoc);
                    return this.m_Frm_DinhNghiaKetChuyenChiPhiTraTruoc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhNghiaKetChuyenChiPhiTraTruoc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhNghiaKetChuyenChiPhiTraTruoc>(ref this.m_Frm_DinhNghiaKetChuyenChiPhiTraTruoc);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhNghiaPhuTung Frm_DinhNghiaPhuTung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhNghiaPhuTung = Create__Instance__<ACCOUNTING.Frm_DinhNghiaPhuTung>(this.m_Frm_DinhNghiaPhuTung);
                    return this.m_Frm_DinhNghiaPhuTung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhNghiaPhuTung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhNghiaPhuTung>(ref this.m_Frm_DinhNghiaPhuTung);
                    }
                }
            }

            public ACCOUNTING.Frm_DinhNghiaTaiKhoanKetChuyen Frm_DinhNghiaTaiKhoanKetChuyen
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DinhNghiaTaiKhoanKetChuyen = Create__Instance__<ACCOUNTING.Frm_DinhNghiaTaiKhoanKetChuyen>(this.m_Frm_DinhNghiaTaiKhoanKetChuyen);
                    return this.m_Frm_DinhNghiaTaiKhoanKetChuyen;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DinhNghiaTaiKhoanKetChuyen)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DinhNghiaTaiKhoanKetChuyen>(ref this.m_Frm_DinhNghiaTaiKhoanKetChuyen);
                    }
                }
            }

            public ACCOUNTING.Frm_DKHangHoa Frm_DKHangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DKHangHoa = Create__Instance__<ACCOUNTING.Frm_DKHangHoa>(this.m_Frm_DKHangHoa);
                    return this.m_Frm_DKHangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DKHangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DKHangHoa>(ref this.m_Frm_DKHangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_DKKhachHang Frm_DKKhachHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DKKhachHang = Create__Instance__<ACCOUNTING.Frm_DKKhachHang>(this.m_Frm_DKKhachHang);
                    return this.m_Frm_DKKhachHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DKKhachHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DKKhachHang>(ref this.m_Frm_DKKhachHang);
                    }
                }
            }

            public ACCOUNTING.Frm_DMChiPhi Frm_DMChiPhi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMChiPhi = Create__Instance__<ACCOUNTING.Frm_DMChiPhi>(this.m_Frm_DMChiPhi);
                    return this.m_Frm_DMChiPhi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMChiPhi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMChiPhi>(ref this.m_Frm_DMChiPhi);
                    }
                }
            }

            public ACCOUNTING.Frm_DMDieuKhoanBaoGia Frm_DMDieuKhoanBaoGia
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMDieuKhoanBaoGia = Create__Instance__<ACCOUNTING.Frm_DMDieuKhoanBaoGia>(this.m_Frm_DMDieuKhoanBaoGia);
                    return this.m_Frm_DMDieuKhoanBaoGia;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMDieuKhoanBaoGia)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMDieuKhoanBaoGia>(ref this.m_Frm_DMDieuKhoanBaoGia);
                    }
                }
            }

            public ACCOUNTING.Frm_DMDonViBoPhan Frm_DMDonViBoPhan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMDonViBoPhan = Create__Instance__<ACCOUNTING.Frm_DMDonViBoPhan>(this.m_Frm_DMDonViBoPhan);
                    return this.m_Frm_DMDonViBoPhan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMDonViBoPhan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMDonViBoPhan>(ref this.m_Frm_DMDonViBoPhan);
                    }
                }
            }

            public ACCOUNTING.Frm_DMDonViTinh Frm_DMDonViTinh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMDonViTinh = Create__Instance__<ACCOUNTING.Frm_DMDonViTinh>(this.m_Frm_DMDonViTinh);
                    return this.m_Frm_DMDonViTinh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMDonViTinh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMDonViTinh>(ref this.m_Frm_DMDonViTinh);
                    }
                }
            }

            public ACCOUNTING.Frm_DMHangHoa Frm_DMHangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMHangHoa = Create__Instance__<ACCOUNTING.Frm_DMHangHoa>(this.m_Frm_DMHangHoa);
                    return this.m_Frm_DMHangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMHangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMHangHoa>(ref this.m_Frm_DMHangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_DMHangMucBaoCaoThue Frm_DMHangMucBaoCaoThue
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMHangMucBaoCaoThue = Create__Instance__<ACCOUNTING.Frm_DMHangMucBaoCaoThue>(this.m_Frm_DMHangMucBaoCaoThue);
                    return this.m_Frm_DMHangMucBaoCaoThue;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMHangMucBaoCaoThue)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMHangMucBaoCaoThue>(ref this.m_Frm_DMHangMucBaoCaoThue);
                    }
                }
            }

            public ACCOUNTING.Frm_DMHangMucSuaChua Frm_DMHangMucSuaChua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMHangMucSuaChua = Create__Instance__<ACCOUNTING.Frm_DMHangMucSuaChua>(this.m_Frm_DMHangMucSuaChua);
                    return this.m_Frm_DMHangMucSuaChua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMHangMucSuaChua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMHangMucSuaChua>(ref this.m_Frm_DMHangMucSuaChua);
                    }
                }
            }

            public ACCOUNTING.Frm_DMHangSanXuat Frm_DMHangSanXuat
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMHangSanXuat = Create__Instance__<ACCOUNTING.Frm_DMHangSanXuat>(this.m_Frm_DMHangSanXuat);
                    return this.m_Frm_DMHangSanXuat;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMHangSanXuat)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMHangSanXuat>(ref this.m_Frm_DMHangSanXuat);
                    }
                }
            }

            public ACCOUNTING.Frm_DMHopDong Frm_DMHopDong
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMHopDong = Create__Instance__<ACCOUNTING.Frm_DMHopDong>(this.m_Frm_DMHopDong);
                    return this.m_Frm_DMHopDong;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMHopDong)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMHopDong>(ref this.m_Frm_DMHopDong);
                    }
                }
            }

            public ACCOUNTING.Frm_DMKhachHang Frm_DMKhachHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMKhachHang = Create__Instance__<ACCOUNTING.Frm_DMKhachHang>(this.m_Frm_DMKhachHang);
                    return this.m_Frm_DMKhachHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMKhachHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMKhachHang>(ref this.m_Frm_DMKhachHang);
                    }
                }
            }

            public ACCOUNTING.Frm_DMKho Frm_DMKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMKho = Create__Instance__<ACCOUNTING.Frm_DMKho>(this.m_Frm_DMKho);
                    return this.m_Frm_DMKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMKho>(ref this.m_Frm_DMKho);
                    }
                }
            }

            public ACCOUNTING.Frm_DMKhoanMucChiPhi Frm_DMKhoanMucChiPhi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMKhoanMucChiPhi = Create__Instance__<ACCOUNTING.Frm_DMKhoanMucChiPhi>(this.m_Frm_DMKhoanMucChiPhi);
                    return this.m_Frm_DMKhoanMucChiPhi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMKhoanMucChiPhi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMKhoanMucChiPhi>(ref this.m_Frm_DMKhoanMucChiPhi);
                    }
                }
            }

            public ACCOUNTING.Frm_DMKhuVuc Frm_DMKhuVuc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMKhuVuc = Create__Instance__<ACCOUNTING.Frm_DMKhuVuc>(this.m_Frm_DMKhuVuc);
                    return this.m_Frm_DMKhuVuc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMKhuVuc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMKhuVuc>(ref this.m_Frm_DMKhuVuc);
                    }
                }
            }

            public ACCOUNTING.Frm_DMLienHeDoiTuong Frm_DMLienHeDoiTuong
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMLienHeDoiTuong = Create__Instance__<ACCOUNTING.Frm_DMLienHeDoiTuong>(this.m_Frm_DMLienHeDoiTuong);
                    return this.m_Frm_DMLienHeDoiTuong;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMLienHeDoiTuong)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMLienHeDoiTuong>(ref this.m_Frm_DMLienHeDoiTuong);
                    }
                }
            }

            public ACCOUNTING.Frm_DMLoaiGia Frm_DMLoaiGia
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMLoaiGia = Create__Instance__<ACCOUNTING.Frm_DMLoaiGia>(this.m_Frm_DMLoaiGia);
                    return this.m_Frm_DMLoaiGia;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMLoaiGia)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMLoaiGia>(ref this.m_Frm_DMLoaiGia);
                    }
                }
            }

            public ACCOUNTING.Frm_DMLoaiHoaDon Frm_DMLoaiHoaDon
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMLoaiHoaDon = Create__Instance__<ACCOUNTING.Frm_DMLoaiHoaDon>(this.m_Frm_DMLoaiHoaDon);
                    return this.m_Frm_DMLoaiHoaDon;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMLoaiHoaDon)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMLoaiHoaDon>(ref this.m_Frm_DMLoaiHoaDon);
                    }
                }
            }

            public ACCOUNTING.Frm_DMLoaiKhachHang Frm_DMLoaiKhachHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMLoaiKhachHang = Create__Instance__<ACCOUNTING.Frm_DMLoaiKhachHang>(this.m_Frm_DMLoaiKhachHang);
                    return this.m_Frm_DMLoaiKhachHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMLoaiKhachHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMLoaiKhachHang>(ref this.m_Frm_DMLoaiKhachHang);
                    }
                }
            }

            public ACCOUNTING.Frm_DMLoaiNhapXuat Frm_DMLoaiNhapXuat
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMLoaiNhapXuat = Create__Instance__<ACCOUNTING.Frm_DMLoaiNhapXuat>(this.m_Frm_DMLoaiNhapXuat);
                    return this.m_Frm_DMLoaiNhapXuat;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMLoaiNhapXuat)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMLoaiNhapXuat>(ref this.m_Frm_DMLoaiNhapXuat);
                    }
                }
            }

            public ACCOUNTING.Frm_DMLoaiTaiSan Frm_DMLoaiTaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMLoaiTaiSan = Create__Instance__<ACCOUNTING.Frm_DMLoaiTaiSan>(this.m_Frm_DMLoaiTaiSan);
                    return this.m_Frm_DMLoaiTaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMLoaiTaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMLoaiTaiSan>(ref this.m_Frm_DMLoaiTaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_DMLoaiTien Frm_DMLoaiTien
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMLoaiTien = Create__Instance__<ACCOUNTING.Frm_DMLoaiTien>(this.m_Frm_DMLoaiTien);
                    return this.m_Frm_DMLoaiTien;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMLoaiTien)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMLoaiTien>(ref this.m_Frm_DMLoaiTien);
                    }
                }
            }

            public ACCOUNTING.Frm_DMLyDoTangGiamTaiSan Frm_DMLyDoTangGiamTaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMLyDoTangGiamTaiSan = Create__Instance__<ACCOUNTING.Frm_DMLyDoTangGiamTaiSan>(this.m_Frm_DMLyDoTangGiamTaiSan);
                    return this.m_Frm_DMLyDoTangGiamTaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMLyDoTangGiamTaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMLyDoTangGiamTaiSan>(ref this.m_Frm_DMLyDoTangGiamTaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_DMNganHang Frm_DMNganHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMNganHang = Create__Instance__<ACCOUNTING.Frm_DMNganHang>(this.m_Frm_DMNganHang);
                    return this.m_Frm_DMNganHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMNganHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMNganHang>(ref this.m_Frm_DMNganHang);
                    }
                }
            }

            public ACCOUNTING.Frm_DMNganhHang Frm_DMNganhHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMNganhHang = Create__Instance__<ACCOUNTING.Frm_DMNganhHang>(this.m_Frm_DMNganhHang);
                    return this.m_Frm_DMNganhHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMNganhHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMNganhHang>(ref this.m_Frm_DMNganhHang);
                    }
                }
            }

            public ACCOUNTING.Frm_DMNganhKinhDoanh Frm_DMNganhKinhDoanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMNganhKinhDoanh = Create__Instance__<ACCOUNTING.Frm_DMNganhKinhDoanh>(this.m_Frm_DMNganhKinhDoanh);
                    return this.m_Frm_DMNganhKinhDoanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMNganhKinhDoanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMNganhKinhDoanh>(ref this.m_Frm_DMNganhKinhDoanh);
                    }
                }
            }

            public ACCOUNTING.Frm_DMNhaCungCap Frm_DMNhaCungCap
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMNhaCungCap = Create__Instance__<ACCOUNTING.Frm_DMNhaCungCap>(this.m_Frm_DMNhaCungCap);
                    return this.m_Frm_DMNhaCungCap;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMNhaCungCap)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMNhaCungCap>(ref this.m_Frm_DMNhaCungCap);
                    }
                }
            }

            public ACCOUNTING.Frm_DMNhanVien Frm_DMNhanVien
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMNhanVien = Create__Instance__<ACCOUNTING.Frm_DMNhanVien>(this.m_Frm_DMNhanVien);
                    return this.m_Frm_DMNhanVien;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMNhanVien)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMNhanVien>(ref this.m_Frm_DMNhanVien);
                    }
                }
            }

            public ACCOUNTING.Frm_DMNhomHangHoa Frm_DMNhomHangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMNhomHangHoa = Create__Instance__<ACCOUNTING.Frm_DMNhomHangHoa>(this.m_Frm_DMNhomHangHoa);
                    return this.m_Frm_DMNhomHangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMNhomHangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMNhomHangHoa>(ref this.m_Frm_DMNhomHangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_DMPhuongThucTamUng Frm_DMPhuongThucTamUng
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMPhuongThucTamUng = Create__Instance__<ACCOUNTING.Frm_DMPhuongThucTamUng>(this.m_Frm_DMPhuongThucTamUng);
                    return this.m_Frm_DMPhuongThucTamUng;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMPhuongThucTamUng)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMPhuongThucTamUng>(ref this.m_Frm_DMPhuongThucTamUng);
                    }
                }
            }

            public ACCOUNTING.Frm_DMPhuongThucThanhToan Frm_DMPhuongThucThanhToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMPhuongThucThanhToan = Create__Instance__<ACCOUNTING.Frm_DMPhuongThucThanhToan>(this.m_Frm_DMPhuongThucThanhToan);
                    return this.m_Frm_DMPhuongThucThanhToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMPhuongThucThanhToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMPhuongThucThanhToan>(ref this.m_Frm_DMPhuongThucThanhToan);
                    }
                }
            }

            public ACCOUNTING.Frm_DMPhuongThucVanChuyen Frm_DMPhuongThucVanChuyen
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMPhuongThucVanChuyen = Create__Instance__<ACCOUNTING.Frm_DMPhuongThucVanChuyen>(this.m_Frm_DMPhuongThucVanChuyen);
                    return this.m_Frm_DMPhuongThucVanChuyen;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMPhuongThucVanChuyen)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMPhuongThucVanChuyen>(ref this.m_Frm_DMPhuongThucVanChuyen);
                    }
                }
            }

            public ACCOUNTING.Frm_DMPhuTungTaiSan Frm_DMPhuTungTaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMPhuTungTaiSan = Create__Instance__<ACCOUNTING.Frm_DMPhuTungTaiSan>(this.m_Frm_DMPhuTungTaiSan);
                    return this.m_Frm_DMPhuTungTaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMPhuTungTaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMPhuTungTaiSan>(ref this.m_Frm_DMPhuTungTaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_DMQuocGia Frm_DMQuocGia
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMQuocGia = Create__Instance__<ACCOUNTING.Frm_DMQuocGia>(this.m_Frm_DMQuocGia);
                    return this.m_Frm_DMQuocGia;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMQuocGia)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMQuocGia>(ref this.m_Frm_DMQuocGia);
                    }
                }
            }

            public ACCOUNTING.Frm_DMSanPhamCongViec Frm_DMSanPhamCongViec
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMSanPhamCongViec = Create__Instance__<ACCOUNTING.Frm_DMSanPhamCongViec>(this.m_Frm_DMSanPhamCongViec);
                    return this.m_Frm_DMSanPhamCongViec;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMSanPhamCongViec)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMSanPhamCongViec>(ref this.m_Frm_DMSanPhamCongViec);
                    }
                }
            }

            public ACCOUNTING.Frm_DMTaiKhoan Frm_DMTaiKhoan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMTaiKhoan = Create__Instance__<ACCOUNTING.Frm_DMTaiKhoan>(this.m_Frm_DMTaiKhoan);
                    return this.m_Frm_DMTaiKhoan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMTaiKhoan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMTaiKhoan>(ref this.m_Frm_DMTaiKhoan);
                    }
                }
            }

            public ACCOUNTING.Frm_DMThongSoHangHoa Frm_DMThongSoHangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMThongSoHangHoa = Create__Instance__<ACCOUNTING.Frm_DMThongSoHangHoa>(this.m_Frm_DMThongSoHangHoa);
                    return this.m_Frm_DMThongSoHangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMThongSoHangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMThongSoHangHoa>(ref this.m_Frm_DMThongSoHangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_DMTinhThanh Frm_DMTinhThanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMTinhThanh = Create__Instance__<ACCOUNTING.Frm_DMTinhThanh>(this.m_Frm_DMTinhThanh);
                    return this.m_Frm_DMTinhThanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMTinhThanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMTinhThanh>(ref this.m_Frm_DMTinhThanh);
                    }
                }
            }

            public ACCOUNTING.Frm_DMViTri Frm_DMViTri
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DMViTri = Create__Instance__<ACCOUNTING.Frm_DMViTri>(this.m_Frm_DMViTri);
                    return this.m_Frm_DMViTri;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DMViTri)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DMViTri>(ref this.m_Frm_DMViTri);
                    }
                }
            }

            public ACCOUNTING.Frm_DoiMatKhau Frm_DoiMatKhau
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DoiMatKhau = Create__Instance__<ACCOUNTING.Frm_DoiMatKhau>(this.m_Frm_DoiMatKhau);
                    return this.m_Frm_DoiMatKhau;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DoiMatKhau)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DoiMatKhau>(ref this.m_Frm_DoiMatKhau);
                    }
                }
            }

            public ACCOUNTING.Frm_DoiTuongThue Frm_DoiTuongThue
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DoiTuongThue = Create__Instance__<ACCOUNTING.Frm_DoiTuongThue>(this.m_Frm_DoiTuongThue);
                    return this.m_Frm_DoiTuongThue;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DoiTuongThue)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DoiTuongThue>(ref this.m_Frm_DoiTuongThue);
                    }
                }
            }

            public ACCOUNTING.Frm_DonDatHangBan Frm_DonDatHangBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DonDatHangBan = Create__Instance__<ACCOUNTING.Frm_DonDatHangBan>(this.m_Frm_DonDatHangBan);
                    return this.m_Frm_DonDatHangBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DonDatHangBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DonDatHangBan>(ref this.m_Frm_DonDatHangBan);
                    }
                }
            }

            public ACCOUNTING.Frm_DonDatHangBanList Frm_DonDatHangBanList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DonDatHangBanList = Create__Instance__<ACCOUNTING.Frm_DonDatHangBanList>(this.m_Frm_DonDatHangBanList);
                    return this.m_Frm_DonDatHangBanList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DonDatHangBanList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DonDatHangBanList>(ref this.m_Frm_DonDatHangBanList);
                    }
                }
            }

            public ACCOUNTING.Frm_DonDatHangMua Frm_DonDatHangMua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DonDatHangMua = Create__Instance__<ACCOUNTING.Frm_DonDatHangMua>(this.m_Frm_DonDatHangMua);
                    return this.m_Frm_DonDatHangMua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DonDatHangMua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DonDatHangMua>(ref this.m_Frm_DonDatHangMua);
                    }
                }
            }

            public ACCOUNTING.Frm_DonDatHangMuaList Frm_DonDatHangMuaList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DonDatHangMuaList = Create__Instance__<ACCOUNTING.Frm_DonDatHangMuaList>(this.m_Frm_DonDatHangMuaList);
                    return this.m_Frm_DonDatHangMuaList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DonDatHangMuaList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DonDatHangMuaList>(ref this.m_Frm_DonDatHangMuaList);
                    }
                }
            }

            public ACCOUNTING.Frm_DSMauHoaDon Frm_DSMauHoaDon
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DSMauHoaDon = Create__Instance__<ACCOUNTING.Frm_DSMauHoaDon>(this.m_Frm_DSMauHoaDon);
                    return this.m_Frm_DSMauHoaDon;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DSMauHoaDon)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DSMauHoaDon>(ref this.m_Frm_DSMauHoaDon);
                    }
                }
            }

            public ACCOUNTING.Frm_DuLieuThue Frm_DuLieuThue
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DuLieuThue = Create__Instance__<ACCOUNTING.Frm_DuLieuThue>(this.m_Frm_DuLieuThue);
                    return this.m_Frm_DuLieuThue;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DuLieuThue)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DuLieuThue>(ref this.m_Frm_DuLieuThue);
                    }
                }
            }

            public ACCOUNTING.Frm_DuyetDonHangBan Frm_DuyetDonHangBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_DuyetDonHangBan = Create__Instance__<ACCOUNTING.Frm_DuyetDonHangBan>(this.m_Frm_DuyetDonHangBan);
                    return this.m_Frm_DuyetDonHangBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_DuyetDonHangBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_DuyetDonHangBan>(ref this.m_Frm_DuyetDonHangBan);
                    }
                }
            }

            public ACCOUNTING.Frm_GetData Frm_GetData
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_GetData = Create__Instance__<ACCOUNTING.Frm_GetData>(this.m_Frm_GetData);
                    return this.m_Frm_GetData;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_GetData)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_GetData>(ref this.m_Frm_GetData);
                    }
                }
            }

            public ACCOUNTING.Frm_GetDataFromLocalSystem Frm_GetDataFromLocalSystem
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_GetDataFromLocalSystem = Create__Instance__<ACCOUNTING.Frm_GetDataFromLocalSystem>(this.m_Frm_GetDataFromLocalSystem);
                    return this.m_Frm_GetDataFromLocalSystem;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_GetDataFromLocalSystem)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_GetDataFromLocalSystem>(ref this.m_Frm_GetDataFromLocalSystem);
                    }
                }
            }

            public ACCOUNTING.Frm_GhiGiamTaiSan Frm_GhiGiamTaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_GhiGiamTaiSan = Create__Instance__<ACCOUNTING.Frm_GhiGiamTaiSan>(this.m_Frm_GhiGiamTaiSan);
                    return this.m_Frm_GhiGiamTaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_GhiGiamTaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_GhiGiamTaiSan>(ref this.m_Frm_GhiGiamTaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_GhiGiamTaiSanList Frm_GhiGiamTaiSanList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_GhiGiamTaiSanList = Create__Instance__<ACCOUNTING.Frm_GhiGiamTaiSanList>(this.m_Frm_GhiGiamTaiSanList);
                    return this.m_Frm_GhiGiamTaiSanList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_GhiGiamTaiSanList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_GhiGiamTaiSanList>(ref this.m_Frm_GhiGiamTaiSanList);
                    }
                }
            }

            public ACCOUNTING.Frm_GhiSoTraHangNhaCungCap Frm_GhiSoTraHangNhaCungCap
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_GhiSoTraHangNhaCungCap = Create__Instance__<ACCOUNTING.Frm_GhiSoTraHangNhaCungCap>(this.m_Frm_GhiSoTraHangNhaCungCap);
                    return this.m_Frm_GhiSoTraHangNhaCungCap;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_GhiSoTraHangNhaCungCap)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_GhiSoTraHangNhaCungCap>(ref this.m_Frm_GhiSoTraHangNhaCungCap);
                    }
                }
            }

            public ACCOUNTING.Frm_GhiSoXuatKho Frm_GhiSoXuatKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_GhiSoXuatKho = Create__Instance__<ACCOUNTING.Frm_GhiSoXuatKho>(this.m_Frm_GhiSoXuatKho);
                    return this.m_Frm_GhiSoXuatKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_GhiSoXuatKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_GhiSoXuatKho>(ref this.m_Frm_GhiSoXuatKho);
                    }
                }
            }

            public ACCOUNTING.Frm_GiaTriMacDinh Frm_GiaTriMacDinh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_GiaTriMacDinh = Create__Instance__<ACCOUNTING.Frm_GiaTriMacDinh>(this.m_Frm_GiaTriMacDinh);
                    return this.m_Frm_GiaTriMacDinh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_GiaTriMacDinh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_GiaTriMacDinh>(ref this.m_Frm_GiaTriMacDinh);
                    }
                }
            }

            public ACCOUNTING.Frm_HangHoa Frm_HangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HangHoa = Create__Instance__<ACCOUNTING.Frm_HangHoa>(this.m_Frm_HangHoa);
                    return this.m_Frm_HangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HangHoa>(ref this.m_Frm_HangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_HangTrenDuongVe Frm_HangTrenDuongVe
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HangTrenDuongVe = Create__Instance__<ACCOUNTING.Frm_HangTrenDuongVe>(this.m_Frm_HangTrenDuongVe);
                    return this.m_Frm_HangTrenDuongVe;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HangTrenDuongVe)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HangTrenDuongVe>(ref this.m_Frm_HangTrenDuongVe);
                    }
                }
            }

            public ACCOUNTING.Frm_HienThiChucNang Frm_HienThiChucNang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HienThiChucNang = Create__Instance__<ACCOUNTING.Frm_HienThiChucNang>(this.m_Frm_HienThiChucNang);
                    return this.m_Frm_HienThiChucNang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HienThiChucNang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HienThiChucNang>(ref this.m_Frm_HienThiChucNang);
                    }
                }
            }

            public ACCOUNTING.Frm_HienThiDuLieu Frm_HienThiDuLieu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HienThiDuLieu = Create__Instance__<ACCOUNTING.Frm_HienThiDuLieu>(this.m_Frm_HienThiDuLieu);
                    return this.m_Frm_HienThiDuLieu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HienThiDuLieu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HienThiDuLieu>(ref this.m_Frm_HienThiDuLieu);
                    }
                }
            }

            public ACCOUNTING.Frm_HinhKyTenDongDau Frm_HinhKyTenDongDau
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HinhKyTenDongDau = Create__Instance__<ACCOUNTING.Frm_HinhKyTenDongDau>(this.m_Frm_HinhKyTenDongDau);
                    return this.m_Frm_HinhKyTenDongDau;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HinhKyTenDongDau)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HinhKyTenDongDau>(ref this.m_Frm_HinhKyTenDongDau);
                    }
                }
            }

            public ACCOUNTING.Frm_HoaDonBanDichVu Frm_HoaDonBanDichVu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HoaDonBanDichVu = Create__Instance__<ACCOUNTING.Frm_HoaDonBanDichVu>(this.m_Frm_HoaDonBanDichVu);
                    return this.m_Frm_HoaDonBanDichVu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HoaDonBanDichVu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HoaDonBanDichVu>(ref this.m_Frm_HoaDonBanDichVu);
                    }
                }
            }

            public ACCOUNTING.Frm_HoaDonBanDichVuList Frm_HoaDonBanDichVuList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HoaDonBanDichVuList = Create__Instance__<ACCOUNTING.Frm_HoaDonBanDichVuList>(this.m_Frm_HoaDonBanDichVuList);
                    return this.m_Frm_HoaDonBanDichVuList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HoaDonBanDichVuList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HoaDonBanDichVuList>(ref this.m_Frm_HoaDonBanDichVuList);
                    }
                }
            }

            public ACCOUNTING.Frm_HoaDonChiNhanh Frm_HoaDonChiNhanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HoaDonChiNhanh = Create__Instance__<ACCOUNTING.Frm_HoaDonChiNhanh>(this.m_Frm_HoaDonChiNhanh);
                    return this.m_Frm_HoaDonChiNhanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HoaDonChiNhanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HoaDonChiNhanh>(ref this.m_Frm_HoaDonChiNhanh);
                    }
                }
            }

            public ACCOUNTING.Frm_HoaDonChiNhanhList Frm_HoaDonChiNhanhList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HoaDonChiNhanhList = Create__Instance__<ACCOUNTING.Frm_HoaDonChiNhanhList>(this.m_Frm_HoaDonChiNhanhList);
                    return this.m_Frm_HoaDonChiNhanhList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HoaDonChiNhanhList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HoaDonChiNhanhList>(ref this.m_Frm_HoaDonChiNhanhList);
                    }
                }
            }

            public ACCOUNTING.Frm_HoaDonMuaDichVu Frm_HoaDonMuaDichVu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HoaDonMuaDichVu = Create__Instance__<ACCOUNTING.Frm_HoaDonMuaDichVu>(this.m_Frm_HoaDonMuaDichVu);
                    return this.m_Frm_HoaDonMuaDichVu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HoaDonMuaDichVu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HoaDonMuaDichVu>(ref this.m_Frm_HoaDonMuaDichVu);
                    }
                }
            }

            public ACCOUNTING.Frm_HoaDonMuaDichVuList Frm_HoaDonMuaDichVuList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HoaDonMuaDichVuList = Create__Instance__<ACCOUNTING.Frm_HoaDonMuaDichVuList>(this.m_Frm_HoaDonMuaDichVuList);
                    return this.m_Frm_HoaDonMuaDichVuList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HoaDonMuaDichVuList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HoaDonMuaDichVuList>(ref this.m_Frm_HoaDonMuaDichVuList);
                    }
                }
            }

            public ACCOUNTING.Frm_HoaDonNhapKhauNoThanhToan Frm_HoaDonNhapKhauNoThanhToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HoaDonNhapKhauNoThanhToan = Create__Instance__<ACCOUNTING.Frm_HoaDonNhapKhauNoThanhToan>(this.m_Frm_HoaDonNhapKhauNoThanhToan);
                    return this.m_Frm_HoaDonNhapKhauNoThanhToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HoaDonNhapKhauNoThanhToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HoaDonNhapKhauNoThanhToan>(ref this.m_Frm_HoaDonNhapKhauNoThanhToan);
                    }
                }
            }

            public ACCOUNTING.Frm_HoaHongList Frm_HoaHongList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HoaHongList = Create__Instance__<ACCOUNTING.Frm_HoaHongList>(this.m_Frm_HoaHongList);
                    return this.m_Frm_HoaHongList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HoaHongList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HoaHongList>(ref this.m_Frm_HoaHongList);
                    }
                }
            }

            public ACCOUNTING.Frm_HopDongBan Frm_HopDongBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HopDongBan = Create__Instance__<ACCOUNTING.Frm_HopDongBan>(this.m_Frm_HopDongBan);
                    return this.m_Frm_HopDongBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HopDongBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HopDongBan>(ref this.m_Frm_HopDongBan);
                    }
                }
            }

            public ACCOUNTING.Frm_HopDongBanList Frm_HopDongBanList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HopDongBanList = Create__Instance__<ACCOUNTING.Frm_HopDongBanList>(this.m_Frm_HopDongBanList);
                    return this.m_Frm_HopDongBanList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HopDongBanList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HopDongBanList>(ref this.m_Frm_HopDongBanList);
                    }
                }
            }

            public ACCOUNTING.Frm_HopDongMua Frm_HopDongMua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HopDongMua = Create__Instance__<ACCOUNTING.Frm_HopDongMua>(this.m_Frm_HopDongMua);
                    return this.m_Frm_HopDongMua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HopDongMua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HopDongMua>(ref this.m_Frm_HopDongMua);
                    }
                }
            }

            public ACCOUNTING.Frm_HopDongMuaBan Frm_HopDongMuaBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HopDongMuaBan = Create__Instance__<ACCOUNTING.Frm_HopDongMuaBan>(this.m_Frm_HopDongMuaBan);
                    return this.m_Frm_HopDongMuaBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HopDongMuaBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HopDongMuaBan>(ref this.m_Frm_HopDongMuaBan);
                    }
                }
            }

            public ACCOUNTING.Frm_HopDongMuaBanList Frm_HopDongMuaBanList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HopDongMuaBanList = Create__Instance__<ACCOUNTING.Frm_HopDongMuaBanList>(this.m_Frm_HopDongMuaBanList);
                    return this.m_Frm_HopDongMuaBanList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HopDongMuaBanList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HopDongMuaBanList>(ref this.m_Frm_HopDongMuaBanList);
                    }
                }
            }

            public ACCOUNTING.Frm_HopDongMuaList Frm_HopDongMuaList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_HopDongMuaList = Create__Instance__<ACCOUNTING.Frm_HopDongMuaList>(this.m_Frm_HopDongMuaList);
                    return this.m_Frm_HopDongMuaList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_HopDongMuaList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_HopDongMuaList>(ref this.m_Frm_HopDongMuaList);
                    }
                }
            }

            public ACCOUNTING.Frm_InHoaDonTuIn Frm_InHoaDonTuIn
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_InHoaDonTuIn = Create__Instance__<ACCOUNTING.Frm_InHoaDonTuIn>(this.m_Frm_InHoaDonTuIn);
                    return this.m_Frm_InHoaDonTuIn;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_InHoaDonTuIn)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_InHoaDonTuIn>(ref this.m_Frm_InHoaDonTuIn);
                    }
                }
            }

            public ACCOUNTING.Frm_InUyNhiemChi Frm_InUyNhiemChi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_InUyNhiemChi = Create__Instance__<ACCOUNTING.Frm_InUyNhiemChi>(this.m_Frm_InUyNhiemChi);
                    return this.m_Frm_InUyNhiemChi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_InUyNhiemChi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_InUyNhiemChi>(ref this.m_Frm_InUyNhiemChi);
                    }
                }
            }

            public ACCOUNTING.Frm_KetChuyenCacKhoanGiamTruVaThue Frm_KetChuyenCacKhoanGiamTruVaThue
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KetChuyenCacKhoanGiamTruVaThue = Create__Instance__<ACCOUNTING.Frm_KetChuyenCacKhoanGiamTruVaThue>(this.m_Frm_KetChuyenCacKhoanGiamTruVaThue);
                    return this.m_Frm_KetChuyenCacKhoanGiamTruVaThue;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KetChuyenCacKhoanGiamTruVaThue)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KetChuyenCacKhoanGiamTruVaThue>(ref this.m_Frm_KetChuyenCacKhoanGiamTruVaThue);
                    }
                }
            }

            public ACCOUNTING.Frm_KetChuyenChiPhi Frm_KetChuyenChiPhi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KetChuyenChiPhi = Create__Instance__<ACCOUNTING.Frm_KetChuyenChiPhi>(this.m_Frm_KetChuyenChiPhi);
                    return this.m_Frm_KetChuyenChiPhi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KetChuyenChiPhi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KetChuyenChiPhi>(ref this.m_Frm_KetChuyenChiPhi);
                    }
                }
            }

            public ACCOUNTING.Frm_KetChuyenSoDu Frm_KetChuyenSoDu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KetChuyenSoDu = Create__Instance__<ACCOUNTING.Frm_KetChuyenSoDu>(this.m_Frm_KetChuyenSoDu);
                    return this.m_Frm_KetChuyenSoDu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KetChuyenSoDu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KetChuyenSoDu>(ref this.m_Frm_KetChuyenSoDu);
                    }
                }
            }

            public ACCOUNTING.Frm_KetNoiCSDL Frm_KetNoiCSDL
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KetNoiCSDL = Create__Instance__<ACCOUNTING.Frm_KetNoiCSDL>(this.m_Frm_KetNoiCSDL);
                    return this.m_Frm_KetNoiCSDL;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KetNoiCSDL)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KetNoiCSDL>(ref this.m_Frm_KetNoiCSDL);
                    }
                }
            }

            public ACCOUNTING.Frm_KeToan Frm_KeToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KeToan = Create__Instance__<ACCOUNTING.Frm_KeToan>(this.m_Frm_KeToan);
                    return this.m_Frm_KeToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KeToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KeToan>(ref this.m_Frm_KeToan);
                    }
                }
            }

            public ACCOUNTING.Frm_GiaThanh Frm_GiaThanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_GiaThanh = Create__Instance__<ACCOUNTING.Frm_GiaThanh>(this.m_Frm_GiaThanh);
                    return this.m_Frm_GiaThanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_GiaThanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_GiaThanh>(ref this.m_Frm_GiaThanh);
                    }
                }
            }

            public ACCOUNTING.Frm_KhachHang Frm_KhachHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhachHang = Create__Instance__<ACCOUNTING.Frm_KhachHang>(this.m_Frm_KhachHang);
                    return this.m_Frm_KhachHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhachHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhachHang>(ref this.m_Frm_KhachHang);
                    }
                }
            }

            public ACCOUNTING.Frm_KhachHangThanhToan Frm_KhachHangThanhToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhachHangThanhToan = Create__Instance__<ACCOUNTING.Frm_KhachHangThanhToan>(this.m_Frm_KhachHangThanhToan);
                    return this.m_Frm_KhachHangThanhToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhachHangThanhToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhachHangThanhToan>(ref this.m_Frm_KhachHangThanhToan);
                    }
                }
            }

            public ACCOUNTING.Frm_KhachHangTraHang Frm_KhachHangTraHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhachHangTraHang = Create__Instance__<ACCOUNTING.Frm_KhachHangTraHang>(this.m_Frm_KhachHangTraHang);
                    return this.m_Frm_KhachHangTraHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhachHangTraHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhachHangTraHang>(ref this.m_Frm_KhachHangTraHang);
                    }
                }
            }

            public ACCOUNTING.Frm_KhachHangTraHangList Frm_KhachHangTraHangList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhachHangTraHangList = Create__Instance__<ACCOUNTING.Frm_KhachHangTraHangList>(this.m_Frm_KhachHangTraHangList);
                    return this.m_Frm_KhachHangTraHangList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhachHangTraHangList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhachHangTraHangList>(ref this.m_Frm_KhachHangTraHangList);
                    }
                }
            }

            public ACCOUNTING.Frm_KhachHangUngTruoc Frm_KhachHangUngTruoc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhachHangUngTruoc = Create__Instance__<ACCOUNTING.Frm_KhachHangUngTruoc>(this.m_Frm_KhachHangUngTruoc);
                    return this.m_Frm_KhachHangUngTruoc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhachHangUngTruoc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhachHangUngTruoc>(ref this.m_Frm_KhachHangUngTruoc);
                    }
                }
            }

            public ACCOUNTING.Frm_KhachHangUngTruocList Frm_KhachHangUngTruocList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhachHangUngTruocList = Create__Instance__<ACCOUNTING.Frm_KhachHangUngTruocList>(this.m_Frm_KhachHangUngTruocList);
                    return this.m_Frm_KhachHangUngTruocList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhachHangUngTruocList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhachHangUngTruocList>(ref this.m_Frm_KhachHangUngTruocList);
                    }
                }
            }

            public ACCOUNTING.Frm_KhaiBaoThue Frm_KhaiBaoThue
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhaiBaoThue = Create__Instance__<ACCOUNTING.Frm_KhaiBaoThue>(this.m_Frm_KhaiBaoThue);
                    return this.m_Frm_KhaiBaoThue;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhaiBaoThue)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhaiBaoThue>(ref this.m_Frm_KhaiBaoThue);
                    }
                }
            }

            public ACCOUNTING.Frm_KhauHaoTaiSan Frm_KhauHaoTaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhauHaoTaiSan = Create__Instance__<ACCOUNTING.Frm_KhauHaoTaiSan>(this.m_Frm_KhauHaoTaiSan);
                    return this.m_Frm_KhauHaoTaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhauHaoTaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhauHaoTaiSan>(ref this.m_Frm_KhauHaoTaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_KhoaSo Frm_KhoaSo
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhoaSo = Create__Instance__<ACCOUNTING.Frm_KhoaSo>(this.m_Frm_KhoaSo);
                    return this.m_Frm_KhoaSo;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhoaSo)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhoaSo>(ref this.m_Frm_KhoaSo);
                    }
                }
            }

            public ACCOUNTING.Frm_KhoHang Frm_KhoHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KhoHang = Create__Instance__<ACCOUNTING.Frm_KhoHang>(this.m_Frm_KhoHang);
                    return this.m_Frm_KhoHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KhoHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KhoHang>(ref this.m_Frm_KhoHang);
                    }
                }
            }

            public ACCOUNTING.Frm_KiemKeHangTonKho Frm_KiemKeHangTonKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KiemKeHangTonKho = Create__Instance__<ACCOUNTING.Frm_KiemKeHangTonKho>(this.m_Frm_KiemKeHangTonKho);
                    return this.m_Frm_KiemKeHangTonKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KiemKeHangTonKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KiemKeHangTonKho>(ref this.m_Frm_KiemKeHangTonKho);
                    }
                }
            }

            public ACCOUNTING.Frm_KiemTraDuLieu Frm_KiemTraDuLieu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KiemTraDuLieu = Create__Instance__<ACCOUNTING.Frm_KiemTraDuLieu>(this.m_Frm_KiemTraDuLieu);
                    return this.m_Frm_KiemTraDuLieu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KiemTraDuLieu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KiemTraDuLieu>(ref this.m_Frm_KiemTraDuLieu);
                    }
                }
            }

            public ACCOUNTING.Frm_KiemTraThietBi Frm_KiemTraThietBi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_KiemTraThietBi = Create__Instance__<ACCOUNTING.Frm_KiemTraThietBi>(this.m_Frm_KiemTraThietBi);
                    return this.m_Frm_KiemTraThietBi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_KiemTraThietBi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_KiemTraThietBi>(ref this.m_Frm_KiemTraThietBi);
                    }
                }
            }

            public ACCOUNTING.Frm_Login Frm_Login
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_Login = Create__Instance__<ACCOUNTING.Frm_Login>(this.m_Frm_Login);
                    return this.m_Frm_Login;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_Login)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_Login>(ref this.m_Frm_Login);
                    }
                }
            }

            public ACCOUNTING.Frm_main Frm_main
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_main = Create__Instance__<ACCOUNTING.Frm_main>(this.m_Frm_main);
                    return this.m_Frm_main;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_main)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_main>(ref this.m_Frm_main);
                    }
                }
            }

            public ACCOUNTING.Frm_Matching Frm_Matching
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_Matching = Create__Instance__<ACCOUNTING.Frm_Matching>(this.m_Frm_Matching);
                    return this.m_Frm_Matching;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_Matching)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_Matching>(ref this.m_Frm_Matching);
                    }
                }
            }

            public ACCOUNTING.Frm_MatchingList Frm_MatchingList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_MatchingList = Create__Instance__<ACCOUNTING.Frm_MatchingList>(this.m_Frm_MatchingList);
                    return this.m_Frm_MatchingList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_MatchingList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_MatchingList>(ref this.m_Frm_MatchingList);
                    }
                }
            }

            public ACCOUNTING.Frm_MayChuChiNhanh Frm_MayChuChiNhanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_MayChuChiNhanh = Create__Instance__<ACCOUNTING.Frm_MayChuChiNhanh>(this.m_Frm_MayChuChiNhanh);
                    return this.m_Frm_MayChuChiNhanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_MayChuChiNhanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_MayChuChiNhanh>(ref this.m_Frm_MayChuChiNhanh);
                    }
                }
            }

            public ACCOUNTING.Frm_MuaHang Frm_MuaHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_MuaHang = Create__Instance__<ACCOUNTING.Frm_MuaHang>(this.m_Frm_MuaHang);
                    return this.m_Frm_MuaHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_MuaHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_MuaHang>(ref this.m_Frm_MuaHang);
                    }
                }
            }

            public ACCOUNTING.Frm_NamThang Frm_NamThang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NamThang = Create__Instance__<ACCOUNTING.Frm_NamThang>(this.m_Frm_NamThang);
                    return this.m_Frm_NamThang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NamThang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NamThang>(ref this.m_Frm_NamThang);
                    }
                }
            }

            public ACCOUNTING.Frm_NguoiDung Frm_NguoiDung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NguoiDung = Create__Instance__<ACCOUNTING.Frm_NguoiDung>(this.m_Frm_NguoiDung);
                    return this.m_Frm_NguoiDung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NguoiDung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NguoiDung>(ref this.m_Frm_NguoiDung);
                    }
                }
            }

            public ACCOUNTING.Frm_NhanDuLieu Frm_NhanDuLieu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhanDuLieu = Create__Instance__<ACCOUNTING.Frm_NhanDuLieu>(this.m_Frm_NhanDuLieu);
                    return this.m_Frm_NhanDuLieu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhanDuLieu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhanDuLieu>(ref this.m_Frm_NhanDuLieu);
                    }
                }
            }

            public ACCOUNTING.Frm_NhanDuLieuTuChiNhanh Frm_NhanDuLieuTuChiNhanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhanDuLieuTuChiNhanh = Create__Instance__<ACCOUNTING.Frm_NhanDuLieuTuChiNhanh>(this.m_Frm_NhanDuLieuTuChiNhanh);
                    return this.m_Frm_NhanDuLieuTuChiNhanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhanDuLieuTuChiNhanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhanDuLieuTuChiNhanh>(ref this.m_Frm_NhanDuLieuTuChiNhanh);
                    }
                }
            }

            public ACCOUNTING.Frm_NhapDuLieu Frm_NhapDuLieu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhapDuLieu = Create__Instance__<ACCOUNTING.Frm_NhapDuLieu>(this.m_Frm_NhapDuLieu);
                    return this.m_Frm_NhapDuLieu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhapDuLieu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhapDuLieu>(ref this.m_Frm_NhapDuLieu);
                    }
                }
            }

            public ACCOUNTING.Frm_NhapKhau Frm_NhapKhau
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhapKhau = Create__Instance__<ACCOUNTING.Frm_NhapKhau>(this.m_Frm_NhapKhau);
                    return this.m_Frm_NhapKhau;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhapKhau)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhapKhau>(ref this.m_Frm_NhapKhau);
                    }
                }
            }

            public ACCOUNTING.Frm_NhapKhauList Frm_NhapKhauList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhapKhauList = Create__Instance__<ACCOUNTING.Frm_NhapKhauList>(this.m_Frm_NhapKhauList);
                    return this.m_Frm_NhapKhauList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhapKhauList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhapKhauList>(ref this.m_Frm_NhapKhauList);
                    }
                }
            }

            public ACCOUNTING.Frm_NhapKho Frm_NhapKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhapKho = Create__Instance__<ACCOUNTING.Frm_NhapKho>(this.m_Frm_NhapKho);
                    return this.m_Frm_NhapKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhapKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhapKho>(ref this.m_Frm_NhapKho);
                    }
                }
            }

            public ACCOUNTING.Frm_NhapKhoList Frm_NhapKhoList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhapKhoList = Create__Instance__<ACCOUNTING.Frm_NhapKhoList>(this.m_Frm_NhapKhoList);
                    return this.m_Frm_NhapKhoList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhapKhoList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhapKhoList>(ref this.m_Frm_NhapKhoList);
                    }
                }
            }

            public ACCOUNTING.Frm_NhapKhoNoiBo Frm_NhapKhoNoiBo
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhapKhoNoiBo = Create__Instance__<ACCOUNTING.Frm_NhapKhoNoiBo>(this.m_Frm_NhapKhoNoiBo);
                    return this.m_Frm_NhapKhoNoiBo;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhapKhoNoiBo)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhapKhoNoiBo>(ref this.m_Frm_NhapKhoNoiBo);
                    }
                }
            }

            public ACCOUNTING.Frm_NhapKhoNoiBoList Frm_NhapKhoNoiBoList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhapKhoNoiBoList = Create__Instance__<ACCOUNTING.Frm_NhapKhoNoiBoList>(this.m_Frm_NhapKhoNoiBoList);
                    return this.m_Frm_NhapKhoNoiBoList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhapKhoNoiBoList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhapKhoNoiBoList>(ref this.m_Frm_NhapKhoNoiBoList);
                    }
                }
            }

            public ACCOUNTING.Frm_NhapSoSeri Frm_NhapSoSeri
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhapSoSeri = Create__Instance__<ACCOUNTING.Frm_NhapSoSeri>(this.m_Frm_NhapSoSeri);
                    return this.m_Frm_NhapSoSeri;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhapSoSeri)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhapSoSeri>(ref this.m_Frm_NhapSoSeri);
                    }
                }
            }

            public ACCOUNTING.Frm_NhatKyChungTu Frm_NhatKyChungTu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NhatKyChungTu = Create__Instance__<ACCOUNTING.Frm_NhatKyChungTu>(this.m_Frm_NhatKyChungTu);
                    return this.m_Frm_NhatKyChungTu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NhatKyChungTu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NhatKyChungTu>(ref this.m_Frm_NhatKyChungTu);
                    }
                }
            }

            public ACCOUNTING.Frm_NopThue Frm_NopThue
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NopThue = Create__Instance__<ACCOUNTING.Frm_NopThue>(this.m_Frm_NopThue);
                    return this.m_Frm_NopThue;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NopThue)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NopThue>(ref this.m_Frm_NopThue);
                    }
                }
            }

            public ACCOUNTING.Frm_NopThueNhapKhau Frm_NopThueNhapKhau
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_NopThueNhapKhau = Create__Instance__<ACCOUNTING.Frm_NopThueNhapKhau>(this.m_Frm_NopThueNhapKhau);
                    return this.m_Frm_NopThueNhapKhau;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_NopThueNhapKhau)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_NopThueNhapKhau>(ref this.m_Frm_NopThueNhapKhau);
                    }
                }
            }

            public ACCOUNTING.Frm_PhaiThu Frm_PhaiThu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhaiThu = Create__Instance__<ACCOUNTING.Frm_PhaiThu>(this.m_Frm_PhaiThu);
                    return this.m_Frm_PhaiThu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhaiThu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhaiThu>(ref this.m_Frm_PhaiThu);
                    }
                }
            }

            public ACCOUNTING.Frm_PhaiThuList Frm_PhaiThuList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhaiThuList = Create__Instance__<ACCOUNTING.Frm_PhaiThuList>(this.m_Frm_PhaiThuList);
                    return this.m_Frm_PhaiThuList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhaiThuList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhaiThuList>(ref this.m_Frm_PhaiThuList);
                    }
                }
            }

            public ACCOUNTING.Frm_PhaiTra Frm_PhaiTra
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhaiTra = Create__Instance__<ACCOUNTING.Frm_PhaiTra>(this.m_Frm_PhaiTra);
                    return this.m_Frm_PhaiTra;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhaiTra)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhaiTra>(ref this.m_Frm_PhaiTra);
                    }
                }
            }

            public ACCOUNTING.Frm_PhaiTraList Frm_PhaiTraList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhaiTraList = Create__Instance__<ACCOUNTING.Frm_PhaiTraList>(this.m_Frm_PhaiTraList);
                    return this.m_Frm_PhaiTraList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhaiTraList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhaiTraList>(ref this.m_Frm_PhaiTraList);
                    }
                }
            }

            public ACCOUNTING.Frm_PhanBoChietKhau Frm_PhanBoChietKhau
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhanBoChietKhau = Create__Instance__<ACCOUNTING.Frm_PhanBoChietKhau>(this.m_Frm_PhanBoChietKhau);
                    return this.m_Frm_PhanBoChietKhau;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhanBoChietKhau)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhanBoChietKhau>(ref this.m_Frm_PhanBoChietKhau);
                    }
                }
            }

            public ACCOUNTING.Frm_PhanBoChiPhi Frm_PhanBoChiPhi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhanBoChiPhi = Create__Instance__<ACCOUNTING.Frm_PhanBoChiPhi>(this.m_Frm_PhanBoChiPhi);
                    return this.m_Frm_PhanBoChiPhi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhanBoChiPhi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhanBoChiPhi>(ref this.m_Frm_PhanBoChiPhi);
                    }
                }
            }

            public ACCOUNTING.Frm_PhanBoChiPhiTraTruoc Frm_PhanBoChiPhiTraTruoc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhanBoChiPhiTraTruoc = Create__Instance__<ACCOUNTING.Frm_PhanBoChiPhiTraTruoc>(this.m_Frm_PhanBoChiPhiTraTruoc);
                    return this.m_Frm_PhanBoChiPhiTraTruoc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhanBoChiPhiTraTruoc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhanBoChiPhiTraTruoc>(ref this.m_Frm_PhanBoChiPhiTraTruoc);
                    }
                }
            }

            public ACCOUNTING.Frm_PhieuChi Frm_PhieuChi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhieuChi = Create__Instance__<ACCOUNTING.Frm_PhieuChi>(this.m_Frm_PhieuChi);
                    return this.m_Frm_PhieuChi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhieuChi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhieuChi>(ref this.m_Frm_PhieuChi);
                    }
                }
            }

            public ACCOUNTING.Frm_PhieuChiList Frm_PhieuChiList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhieuChiList = Create__Instance__<ACCOUNTING.Frm_PhieuChiList>(this.m_Frm_PhieuChiList);
                    return this.m_Frm_PhieuChiList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhieuChiList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhieuChiList>(ref this.m_Frm_PhieuChiList);
                    }
                }
            }

            public ACCOUNTING.Frm_PhieuGiaoHang Frm_PhieuGiaoHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhieuGiaoHang = Create__Instance__<ACCOUNTING.Frm_PhieuGiaoHang>(this.m_Frm_PhieuGiaoHang);
                    return this.m_Frm_PhieuGiaoHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhieuGiaoHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhieuGiaoHang>(ref this.m_Frm_PhieuGiaoHang);
                    }
                }
            }

            public ACCOUNTING.Frm_PhieuGiaoHangList Frm_PhieuGiaoHangList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhieuGiaoHangList = Create__Instance__<ACCOUNTING.Frm_PhieuGiaoHangList>(this.m_Frm_PhieuGiaoHangList);
                    return this.m_Frm_PhieuGiaoHangList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhieuGiaoHangList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhieuGiaoHangList>(ref this.m_Frm_PhieuGiaoHangList);
                    }
                }
            }

            public ACCOUNTING.Frm_PhieuThu Frm_PhieuThu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhieuThu = Create__Instance__<ACCOUNTING.Frm_PhieuThu>(this.m_Frm_PhieuThu);
                    return this.m_Frm_PhieuThu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhieuThu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhieuThu>(ref this.m_Frm_PhieuThu);
                    }
                }
            }

            public ACCOUNTING.Frm_PhieuThuList Frm_PhieuThuList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhieuThuList = Create__Instance__<ACCOUNTING.Frm_PhieuThuList>(this.m_Frm_PhieuThuList);
                    return this.m_Frm_PhieuThuList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhieuThuList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhieuThuList>(ref this.m_Frm_PhieuThuList);
                    }
                }
            }

            public ACCOUNTING.Frm_PhieuThuTien Frm_PhieuThuTien
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhieuThuTien = Create__Instance__<ACCOUNTING.Frm_PhieuThuTien>(this.m_Frm_PhieuThuTien);
                    return this.m_Frm_PhieuThuTien;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhieuThuTien)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhieuThuTien>(ref this.m_Frm_PhieuThuTien);
                    }
                }
            }

            public ACCOUNTING.Frm_PhuTungTaiSan Frm_PhuTungTaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_PhuTungTaiSan = Create__Instance__<ACCOUNTING.Frm_PhuTungTaiSan>(this.m_Frm_PhuTungTaiSan);
                    return this.m_Frm_PhuTungTaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_PhuTungTaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_PhuTungTaiSan>(ref this.m_Frm_PhuTungTaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_QuyenDuyetDonHang Frm_QuyenDuyetDonHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_QuyenDuyetDonHang = Create__Instance__<ACCOUNTING.Frm_QuyenDuyetDonHang>(this.m_Frm_QuyenDuyetDonHang);
                    return this.m_Frm_QuyenDuyetDonHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_QuyenDuyetDonHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_QuyenDuyetDonHang>(ref this.m_Frm_QuyenDuyetDonHang);
                    }
                }
            }

            public ACCOUNTING.Frm_QuyenNguoiSuDung Frm_QuyenNguoiSuDung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_QuyenNguoiSuDung = Create__Instance__<ACCOUNTING.Frm_QuyenNguoiSuDung>(this.m_Frm_QuyenNguoiSuDung);
                    return this.m_Frm_QuyenNguoiSuDung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_QuyenNguoiSuDung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_QuyenNguoiSuDung>(ref this.m_Frm_QuyenNguoiSuDung);
                    }
                }
            }

            public ACCOUNTING.Frm_QuyenNhomNguoiDung Frm_QuyenNhomNguoiDung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_QuyenNhomNguoiDung = Create__Instance__<ACCOUNTING.Frm_QuyenNhomNguoiDung>(this.m_Frm_QuyenNhomNguoiDung);
                    return this.m_Frm_QuyenNhomNguoiDung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_QuyenNhomNguoiDung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_QuyenNhomNguoiDung>(ref this.m_Frm_QuyenNhomNguoiDung);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangCanDoiSoPhatSinh Frm_RptBangCanDoiSoPhatSinh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangCanDoiSoPhatSinh = Create__Instance__<ACCOUNTING.Frm_RptBangCanDoiSoPhatSinh>(this.m_Frm_RptBangCanDoiSoPhatSinh);
                    return this.m_Frm_RptBangCanDoiSoPhatSinh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangCanDoiSoPhatSinh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangCanDoiSoPhatSinh>(ref this.m_Frm_RptBangCanDoiSoPhatSinh);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangCanDoiTaiKhoan Frm_RptBangCanDoiTaiKhoan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangCanDoiTaiKhoan = Create__Instance__<ACCOUNTING.Frm_RptBangCanDoiTaiKhoan>(this.m_Frm_RptBangCanDoiTaiKhoan);
                    return this.m_Frm_RptBangCanDoiTaiKhoan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangCanDoiTaiKhoan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangCanDoiTaiKhoan>(ref this.m_Frm_RptBangCanDoiTaiKhoan);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangGiaHangHoa Frm_RptBangGiaHangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangGiaHangHoa = Create__Instance__<ACCOUNTING.Frm_RptBangGiaHangHoa>(this.m_Frm_RptBangGiaHangHoa);
                    return this.m_Frm_RptBangGiaHangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangGiaHangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangGiaHangHoa>(ref this.m_Frm_RptBangGiaHangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKeDoanhThuChiPHi Frm_RptBangKeDoanhThuChiPHi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKeDoanhThuChiPHi = Create__Instance__<ACCOUNTING.Frm_RptBangKeDoanhThuChiPHi>(this.m_Frm_RptBangKeDoanhThuChiPHi);
                    return this.m_Frm_RptBangKeDoanhThuChiPHi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKeDoanhThuChiPHi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKeDoanhThuChiPHi>(ref this.m_Frm_RptBangKeDoanhThuChiPHi);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKeHangHoaTonDuoiDinhMuc Frm_RptBangKeHangHoaTonDuoiDinhMuc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKeHangHoaTonDuoiDinhMuc = Create__Instance__<ACCOUNTING.Frm_RptBangKeHangHoaTonDuoiDinhMuc>(this.m_Frm_RptBangKeHangHoaTonDuoiDinhMuc);
                    return this.m_Frm_RptBangKeHangHoaTonDuoiDinhMuc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKeHangHoaTonDuoiDinhMuc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKeHangHoaTonDuoiDinhMuc>(ref this.m_Frm_RptBangKeHangHoaTonDuoiDinhMuc);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKeHangHoaTonKho Frm_RptBangKeHangHoaTonKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKeHangHoaTonKho = Create__Instance__<ACCOUNTING.Frm_RptBangKeHangHoaTonKho>(this.m_Frm_RptBangKeHangHoaTonKho);
                    return this.m_Frm_RptBangKeHangHoaTonKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKeHangHoaTonKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKeHangHoaTonKho>(ref this.m_Frm_RptBangKeHangHoaTonKho);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKeHangHoaTraLai Frm_RptBangKeHangHoaTraLai
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKeHangHoaTraLai = Create__Instance__<ACCOUNTING.Frm_RptBangKeHangHoaTraLai>(this.m_Frm_RptBangKeHangHoaTraLai);
                    return this.m_Frm_RptBangKeHangHoaTraLai;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKeHangHoaTraLai)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKeHangHoaTraLai>(ref this.m_Frm_RptBangKeHangHoaTraLai);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKeHoaDonNoThanhToan Frm_RptBangKeHoaDonNoThanhToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKeHoaDonNoThanhToan = Create__Instance__<ACCOUNTING.Frm_RptBangKeHoaDonNoThanhToan>(this.m_Frm_RptBangKeHoaDonNoThanhToan);
                    return this.m_Frm_RptBangKeHoaDonNoThanhToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKeHoaDonNoThanhToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKeHoaDonNoThanhToan>(ref this.m_Frm_RptBangKeHoaDonNoThanhToan);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKeHoaHong Frm_RptBangKeHoaHong
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKeHoaHong = Create__Instance__<ACCOUNTING.Frm_RptBangKeHoaHong>(this.m_Frm_RptBangKeHoaHong);
                    return this.m_Frm_RptBangKeHoaHong;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKeHoaHong)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKeHoaHong>(ref this.m_Frm_RptBangKeHoaHong);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKePhieuChi Frm_RptBangKePhieuChi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKePhieuChi = Create__Instance__<ACCOUNTING.Frm_RptBangKePhieuChi>(this.m_Frm_RptBangKePhieuChi);
                    return this.m_Frm_RptBangKePhieuChi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKePhieuChi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKePhieuChi>(ref this.m_Frm_RptBangKePhieuChi);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKePhieuNhapKhau Frm_RptBangKePhieuNhapKhau
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKePhieuNhapKhau = Create__Instance__<ACCOUNTING.Frm_RptBangKePhieuNhapKhau>(this.m_Frm_RptBangKePhieuNhapKhau);
                    return this.m_Frm_RptBangKePhieuNhapKhau;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKePhieuNhapKhau)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKePhieuNhapKhau>(ref this.m_Frm_RptBangKePhieuNhapKhau);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKePhieuNhapKho Frm_RptBangKePhieuNhapKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKePhieuNhapKho = Create__Instance__<ACCOUNTING.Frm_RptBangKePhieuNhapKho>(this.m_Frm_RptBangKePhieuNhapKho);
                    return this.m_Frm_RptBangKePhieuNhapKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKePhieuNhapKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKePhieuNhapKho>(ref this.m_Frm_RptBangKePhieuNhapKho);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKePhieuThu Frm_RptBangKePhieuThu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKePhieuThu = Create__Instance__<ACCOUNTING.Frm_RptBangKePhieuThu>(this.m_Frm_RptBangKePhieuThu);
                    return this.m_Frm_RptBangKePhieuThu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKePhieuThu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKePhieuThu>(ref this.m_Frm_RptBangKePhieuThu);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKePhieuXuatKho Frm_RptBangKePhieuXuatKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKePhieuXuatKho = Create__Instance__<ACCOUNTING.Frm_RptBangKePhieuXuatKho>(this.m_Frm_RptBangKePhieuXuatKho);
                    return this.m_Frm_RptBangKePhieuXuatKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKePhieuXuatKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKePhieuXuatKho>(ref this.m_Frm_RptBangKePhieuXuatKho);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKeThietBiSuaChua Frm_RptBangKeThietBiSuaChua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKeThietBiSuaChua = Create__Instance__<ACCOUNTING.Frm_RptBangKeThietBiSuaChua>(this.m_Frm_RptBangKeThietBiSuaChua);
                    return this.m_Frm_RptBangKeThietBiSuaChua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKeThietBiSuaChua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKeThietBiSuaChua>(ref this.m_Frm_RptBangKeThietBiSuaChua);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangKeTraHangNhaCungCap Frm_RptBangKeTraHangNhaCungCap
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangKeTraHangNhaCungCap = Create__Instance__<ACCOUNTING.Frm_RptBangKeTraHangNhaCungCap>(this.m_Frm_RptBangKeTraHangNhaCungCap);
                    return this.m_Frm_RptBangKeTraHangNhaCungCap;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangKeTraHangNhaCungCap)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangKeTraHangNhaCungCap>(ref this.m_Frm_RptBangKeTraHangNhaCungCap);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBangTinhKhauHao Frm_RptBangTinhKhauHao
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBangTinhKhauHao = Create__Instance__<ACCOUNTING.Frm_RptBangTinhKhauHao>(this.m_Frm_RptBangTinhKhauHao);
                    return this.m_Frm_RptBangTinhKhauHao;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBangTinhKhauHao)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBangTinhKhauHao>(ref this.m_Frm_RptBangTinhKhauHao);
                    }
                }
            }

            public ACCOUNTING.Frm_RptBaoCaoKyGoiDaiLy Frm_RptBaoCaoKyGoiDaiLy
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptBaoCaoKyGoiDaiLy = Create__Instance__<ACCOUNTING.Frm_RptBaoCaoKyGoiDaiLy>(this.m_Frm_RptBaoCaoKyGoiDaiLy);
                    return this.m_Frm_RptBaoCaoKyGoiDaiLy;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptBaoCaoKyGoiDaiLy)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptBaoCaoKyGoiDaiLy>(ref this.m_Frm_RptBaoCaoKyGoiDaiLy);
                    }
                }
            }

            public ACCOUNTING.Frm_RptChiPhiMuaHang Frm_RptChiPhiMuaHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptChiPhiMuaHang = Create__Instance__<ACCOUNTING.Frm_RptChiPhiMuaHang>(this.m_Frm_RptChiPhiMuaHang);
                    return this.m_Frm_RptChiPhiMuaHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptChiPhiMuaHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptChiPhiMuaHang>(ref this.m_Frm_RptChiPhiMuaHang);
                    }
                }
            }

            public ACCOUNTING.Frm_RptChiTietCongNo Frm_RptChiTietCongNo
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptChiTietCongNo = Create__Instance__<ACCOUNTING.Frm_RptChiTietCongNo>(this.m_Frm_RptChiTietCongNo);
                    return this.m_Frm_RptChiTietCongNo;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptChiTietCongNo)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptChiTietCongNo>(ref this.m_Frm_RptChiTietCongNo);
                    }
                }
            }

            public ACCOUNTING.Frm_RptCongNoChiTiet Frm_RptCongNoChiTiet
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptCongNoChiTiet = Create__Instance__<ACCOUNTING.Frm_RptCongNoChiTiet>(this.m_Frm_RptCongNoChiTiet);
                    return this.m_Frm_RptCongNoChiTiet;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptCongNoChiTiet)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptCongNoChiTiet>(ref this.m_Frm_RptCongNoChiTiet);
                    }
                }
            }

            public ACCOUNTING.Frm_RptCongNoPhaiTra Frm_RptCongNoPhaiTra
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptCongNoPhaiTra = Create__Instance__<ACCOUNTING.Frm_RptCongNoPhaiTra>(this.m_Frm_RptCongNoPhaiTra);
                    return this.m_Frm_RptCongNoPhaiTra;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptCongNoPhaiTra)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptCongNoPhaiTra>(ref this.m_Frm_RptCongNoPhaiTra);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDanhSachTaiSanCoDinh Frm_RptDanhSachTaiSanCoDinh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDanhSachTaiSanCoDinh = Create__Instance__<ACCOUNTING.Frm_RptDanhSachTaiSanCoDinh>(this.m_Frm_RptDanhSachTaiSanCoDinh);
                    return this.m_Frm_RptDanhSachTaiSanCoDinh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDanhSachTaiSanCoDinh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDanhSachTaiSanCoDinh>(ref this.m_Frm_RptDanhSachTaiSanCoDinh);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuChiTiet Frm_RptDoanhThuChiTiet
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuChiTiet = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuChiTiet>(this.m_Frm_RptDoanhThuChiTiet);
                    return this.m_Frm_RptDoanhThuChiTiet;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuChiTiet)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuChiTiet>(ref this.m_Frm_RptDoanhThuChiTiet);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuTheoKhachHang Frm_RptDoanhThuTheoKhachHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuTheoKhachHang = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoKhachHang>(this.m_Frm_RptDoanhThuTheoKhachHang);
                    return this.m_Frm_RptDoanhThuTheoKhachHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuTheoKhachHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoKhachHang>(ref this.m_Frm_RptDoanhThuTheoKhachHang);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuTheoKhuVuc Frm_RptDoanhThuTheoKhuVuc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuTheoKhuVuc = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoKhuVuc>(this.m_Frm_RptDoanhThuTheoKhuVuc);
                    return this.m_Frm_RptDoanhThuTheoKhuVuc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuTheoKhuVuc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoKhuVuc>(ref this.m_Frm_RptDoanhThuTheoKhuVuc);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuTheoLoaiKH Frm_RptDoanhThuTheoLoaiKH
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuTheoLoaiKH = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoLoaiKH>(this.m_Frm_RptDoanhThuTheoLoaiKH);
                    return this.m_Frm_RptDoanhThuTheoLoaiKH;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuTheoLoaiKH)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoLoaiKH>(ref this.m_Frm_RptDoanhThuTheoLoaiKH);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuTheoMatHang Frm_RptDoanhThuTheoMatHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuTheoMatHang = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoMatHang>(this.m_Frm_RptDoanhThuTheoMatHang);
                    return this.m_Frm_RptDoanhThuTheoMatHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuTheoMatHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoMatHang>(ref this.m_Frm_RptDoanhThuTheoMatHang);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuTheoMatHangChiTiet Frm_RptDoanhThuTheoMatHangChiTiet
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuTheoMatHangChiTiet = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoMatHangChiTiet>(this.m_Frm_RptDoanhThuTheoMatHangChiTiet);
                    return this.m_Frm_RptDoanhThuTheoMatHangChiTiet;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuTheoMatHangChiTiet)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoMatHangChiTiet>(ref this.m_Frm_RptDoanhThuTheoMatHangChiTiet);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuTheoNgay Frm_RptDoanhThuTheoNgay
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuTheoNgay = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoNgay>(this.m_Frm_RptDoanhThuTheoNgay);
                    return this.m_Frm_RptDoanhThuTheoNgay;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuTheoNgay)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoNgay>(ref this.m_Frm_RptDoanhThuTheoNgay);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuTheoSanPham Frm_RptDoanhThuTheoSanPham
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuTheoSanPham = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoSanPham>(this.m_Frm_RptDoanhThuTheoSanPham);
                    return this.m_Frm_RptDoanhThuTheoSanPham;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuTheoSanPham)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuTheoSanPham>(ref this.m_Frm_RptDoanhThuTheoSanPham);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoanhThuTongHop Frm_RptDoanhThuTongHop
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoanhThuTongHop = Create__Instance__<ACCOUNTING.Frm_RptDoanhThuTongHop>(this.m_Frm_RptDoanhThuTongHop);
                    return this.m_Frm_RptDoanhThuTongHop;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoanhThuTongHop)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoanhThuTongHop>(ref this.m_Frm_RptDoanhThuTongHop);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoiChieuCongNoPhaiThu Frm_RptDoiChieuCongNoPhaiThu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoiChieuCongNoPhaiThu = Create__Instance__<ACCOUNTING.Frm_RptDoiChieuCongNoPhaiThu>(this.m_Frm_RptDoiChieuCongNoPhaiThu);
                    return this.m_Frm_RptDoiChieuCongNoPhaiThu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoiChieuCongNoPhaiThu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoiChieuCongNoPhaiThu>(ref this.m_Frm_RptDoiChieuCongNoPhaiThu);
                    }
                }
            }

            public ACCOUNTING.Frm_RptDoiChieuCongNoPhaiTra Frm_RptDoiChieuCongNoPhaiTra
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptDoiChieuCongNoPhaiTra = Create__Instance__<ACCOUNTING.Frm_RptDoiChieuCongNoPhaiTra>(this.m_Frm_RptDoiChieuCongNoPhaiTra);
                    return this.m_Frm_RptDoiChieuCongNoPhaiTra;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptDoiChieuCongNoPhaiTra)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptDoiChieuCongNoPhaiTra>(ref this.m_Frm_RptDoiChieuCongNoPhaiTra);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHeHanSuDung Frm_RptHeHanSuDung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHeHanSuDung = Create__Instance__<ACCOUNTING.Frm_RptHeHanSuDung>(this.m_Frm_RptHeHanSuDung);
                    return this.m_Frm_RptHeHanSuDung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHeHanSuDung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHeHanSuDung>(ref this.m_Frm_RptHeHanSuDung);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHoaDonBanDichVu Frm_RptHoaDonBanDichVu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHoaDonBanDichVu = Create__Instance__<ACCOUNTING.Frm_RptHoaDonBanDichVu>(this.m_Frm_RptHoaDonBanDichVu);
                    return this.m_Frm_RptHoaDonBanDichVu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHoaDonBanDichVu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHoaDonBanDichVu>(ref this.m_Frm_RptHoaDonBanDichVu);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHoaDonBanHang Frm_RptHoaDonBanHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHoaDonBanHang = Create__Instance__<ACCOUNTING.Frm_RptHoaDonBanHang>(this.m_Frm_RptHoaDonBanHang);
                    return this.m_Frm_RptHoaDonBanHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHoaDonBanHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHoaDonBanHang>(ref this.m_Frm_RptHoaDonBanHang);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHoaDonBanHangCoChietKhau Frm_RptHoaDonBanHangCoChietKhau
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHoaDonBanHangCoChietKhau = Create__Instance__<ACCOUNTING.Frm_RptHoaDonBanHangCoChietKhau>(this.m_Frm_RptHoaDonBanHangCoChietKhau);
                    return this.m_Frm_RptHoaDonBanHangCoChietKhau;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHoaDonBanHangCoChietKhau)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHoaDonBanHangCoChietKhau>(ref this.m_Frm_RptHoaDonBanHangCoChietKhau);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHoaDonBanRa Frm_RptHoaDonBanRa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHoaDonBanRa = Create__Instance__<ACCOUNTING.Frm_RptHoaDonBanRa>(this.m_Frm_RptHoaDonBanRa);
                    return this.m_Frm_RptHoaDonBanRa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHoaDonBanRa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHoaDonBanRa>(ref this.m_Frm_RptHoaDonBanRa);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHoaDonChuaThanhToan Frm_RptHoaDonChuaThanhToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHoaDonChuaThanhToan = Create__Instance__<ACCOUNTING.Frm_RptHoaDonChuaThanhToan>(this.m_Frm_RptHoaDonChuaThanhToan);
                    return this.m_Frm_RptHoaDonChuaThanhToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHoaDonChuaThanhToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHoaDonChuaThanhToan>(ref this.m_Frm_RptHoaDonChuaThanhToan);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHoaDonDenHanThanhToan Frm_RptHoaDonDenHanThanhToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHoaDonDenHanThanhToan = Create__Instance__<ACCOUNTING.Frm_RptHoaDonDenHanThanhToan>(this.m_Frm_RptHoaDonDenHanThanhToan);
                    return this.m_Frm_RptHoaDonDenHanThanhToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHoaDonDenHanThanhToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHoaDonDenHanThanhToan>(ref this.m_Frm_RptHoaDonDenHanThanhToan);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHoaDonMuaVao Frm_RptHoaDonMuaVao
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHoaDonMuaVao = Create__Instance__<ACCOUNTING.Frm_RptHoaDonMuaVao>(this.m_Frm_RptHoaDonMuaVao);
                    return this.m_Frm_RptHoaDonMuaVao;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHoaDonMuaVao)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHoaDonMuaVao>(ref this.m_Frm_RptHoaDonMuaVao);
                    }
                }
            }

            public ACCOUNTING.Frm_RptHoaDonNoThanhToan Frm_RptHoaDonNoThanhToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptHoaDonNoThanhToan = Create__Instance__<ACCOUNTING.Frm_RptHoaDonNoThanhToan>(this.m_Frm_RptHoaDonNoThanhToan);
                    return this.m_Frm_RptHoaDonNoThanhToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptHoaDonNoThanhToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptHoaDonNoThanhToan>(ref this.m_Frm_RptHoaDonNoThanhToan);
                    }
                }
            }

            public ACCOUNTING.Frm_RptKetQuaHoatDongKinhDoanh Frm_RptKetQuaHoatDongKinhDoanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptKetQuaHoatDongKinhDoanh = Create__Instance__<ACCOUNTING.Frm_RptKetQuaHoatDongKinhDoanh>(this.m_Frm_RptKetQuaHoatDongKinhDoanh);
                    return this.m_Frm_RptKetQuaHoatDongKinhDoanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptKetQuaHoatDongKinhDoanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptKetQuaHoatDongKinhDoanh>(ref this.m_Frm_RptKetQuaHoatDongKinhDoanh);
                    }
                }
            }

            public ACCOUNTING.Frm_RptKhachHangNoVuotDinhMuc Frm_RptKhachHangNoVuotDinhMuc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptKhachHangNoVuotDinhMuc = Create__Instance__<ACCOUNTING.Frm_RptKhachHangNoVuotDinhMuc>(this.m_Frm_RptKhachHangNoVuotDinhMuc);
                    return this.m_Frm_RptKhachHangNoVuotDinhMuc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptKhachHangNoVuotDinhMuc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptKhachHangNoVuotDinhMuc>(ref this.m_Frm_RptKhachHangNoVuotDinhMuc);
                    }
                }
            }

            public ACCOUNTING.Frm_RptKhauHao Frm_RptKhauHao
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptKhauHao = Create__Instance__<ACCOUNTING.Frm_RptKhauHao>(this.m_Frm_RptKhauHao);
                    return this.m_Frm_RptKhauHao;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptKhauHao)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptKhauHao>(ref this.m_Frm_RptKhauHao);
                    }
                }
            }

            public ACCOUNTING.Frm_RptLuuChuyenTien Frm_RptLuuChuyenTien
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptLuuChuyenTien = Create__Instance__<ACCOUNTING.Frm_RptLuuChuyenTien>(this.m_Frm_RptLuuChuyenTien);
                    return this.m_Frm_RptLuuChuyenTien;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptLuuChuyenTien)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptLuuChuyenTien>(ref this.m_Frm_RptLuuChuyenTien);
                    }
                }
            }

            public ACCOUNTING.Frm_RptNhapXuatTonKho Frm_RptNhapXuatTonKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptNhapXuatTonKho = Create__Instance__<ACCOUNTING.Frm_RptNhapXuatTonKho>(this.m_Frm_RptNhapXuatTonKho);
                    return this.m_Frm_RptNhapXuatTonKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptNhapXuatTonKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptNhapXuatTonKho>(ref this.m_Frm_RptNhapXuatTonKho);
                    }
                }
            }

            public ACCOUNTING.Frm_RptQuaTrinhKhauHao Frm_RptQuaTrinhKhauHao
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptQuaTrinhKhauHao = Create__Instance__<ACCOUNTING.Frm_RptQuaTrinhKhauHao>(this.m_Frm_RptQuaTrinhKhauHao);
                    return this.m_Frm_RptQuaTrinhKhauHao;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptQuaTrinhKhauHao)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptQuaTrinhKhauHao>(ref this.m_Frm_RptQuaTrinhKhauHao);
                    }
                }
            }

            public ACCOUNTING.Frm_RptQuyTienGoiNganHang Frm_RptQuyTienGoiNganHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptQuyTienGoiNganHang = Create__Instance__<ACCOUNTING.Frm_RptQuyTienGoiNganHang>(this.m_Frm_RptQuyTienGoiNganHang);
                    return this.m_Frm_RptQuyTienGoiNganHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptQuyTienGoiNganHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptQuyTienGoiNganHang>(ref this.m_Frm_RptQuyTienGoiNganHang);
                    }
                }
            }

            public ACCOUNTING.Frm_RptQuyTienMat Frm_RptQuyTienMat
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptQuyTienMat = Create__Instance__<ACCOUNTING.Frm_RptQuyTienMat>(this.m_Frm_RptQuyTienMat);
                    return this.m_Frm_RptQuyTienMat;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptQuyTienMat)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptQuyTienMat>(ref this.m_Frm_RptQuyTienMat);
                    }
                }
            }

            public ACCOUNTING.Frm_RptSoCaiChiTietTaiKhoan Frm_RptSoCaiChiTietTaiKhoan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptSoCaiChiTietTaiKhoan = Create__Instance__<ACCOUNTING.Frm_RptSoCaiChiTietTaiKhoan>(this.m_Frm_RptSoCaiChiTietTaiKhoan);
                    return this.m_Frm_RptSoCaiChiTietTaiKhoan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptSoCaiChiTietTaiKhoan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptSoCaiChiTietTaiKhoan>(ref this.m_Frm_RptSoCaiChiTietTaiKhoan);
                    }
                }
            }

            public ACCOUNTING.Frm_RptSoCaiTaiKhoan Frm_RptSoCaiTaiKhoan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptSoCaiTaiKhoan = Create__Instance__<ACCOUNTING.Frm_RptSoCaiTaiKhoan>(this.m_Frm_RptSoCaiTaiKhoan);
                    return this.m_Frm_RptSoCaiTaiKhoan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptSoCaiTaiKhoan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptSoCaiTaiKhoan>(ref this.m_Frm_RptSoCaiTaiKhoan);
                    }
                }
            }

            public ACCOUNTING.Frm_RptSoNhatKyBanHang Frm_RptSoNhatKyBanHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptSoNhatKyBanHang = Create__Instance__<ACCOUNTING.Frm_RptSoNhatKyBanHang>(this.m_Frm_RptSoNhatKyBanHang);
                    return this.m_Frm_RptSoNhatKyBanHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptSoNhatKyBanHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptSoNhatKyBanHang>(ref this.m_Frm_RptSoNhatKyBanHang);
                    }
                }
            }

            public ACCOUNTING.Frm_RptSoNhatKyChiTien Frm_RptSoNhatKyChiTien
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptSoNhatKyChiTien = Create__Instance__<ACCOUNTING.Frm_RptSoNhatKyChiTien>(this.m_Frm_RptSoNhatKyChiTien);
                    return this.m_Frm_RptSoNhatKyChiTien;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptSoNhatKyChiTien)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptSoNhatKyChiTien>(ref this.m_Frm_RptSoNhatKyChiTien);
                    }
                }
            }

            public ACCOUNTING.Frm_RptSoNhatKyMuaHang Frm_RptSoNhatKyMuaHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptSoNhatKyMuaHang = Create__Instance__<ACCOUNTING.Frm_RptSoNhatKyMuaHang>(this.m_Frm_RptSoNhatKyMuaHang);
                    return this.m_Frm_RptSoNhatKyMuaHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptSoNhatKyMuaHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptSoNhatKyMuaHang>(ref this.m_Frm_RptSoNhatKyMuaHang);
                    }
                }
            }

            public ACCOUNTING.Frm_RptSoNhatKyThuTien Frm_RptSoNhatKyThuTien
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptSoNhatKyThuTien = Create__Instance__<ACCOUNTING.Frm_RptSoNhatKyThuTien>(this.m_Frm_RptSoNhatKyThuTien);
                    return this.m_Frm_RptSoNhatKyThuTien;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptSoNhatKyThuTien)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptSoNhatKyThuTien>(ref this.m_Frm_RptSoNhatKyThuTien);
                    }
                }
            }

            public ACCOUNTING.Frm_RptThueNhapKhauDenHanNop Frm_RptThueNhapKhauDenHanNop
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptThueNhapKhauDenHanNop = Create__Instance__<ACCOUNTING.Frm_RptThueNhapKhauDenHanNop>(this.m_Frm_RptThueNhapKhauDenHanNop);
                    return this.m_Frm_RptThueNhapKhauDenHanNop;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptThueNhapKhauDenHanNop)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptThueNhapKhauDenHanNop>(ref this.m_Frm_RptThueNhapKhauDenHanNop);
                    }
                }
            }

            public ACCOUNTING.Frm_RptThuyetMinhChiPhi Frm_RptThuyetMinhChiPhi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptThuyetMinhChiPhi = Create__Instance__<ACCOUNTING.Frm_RptThuyetMinhChiPhi>(this.m_Frm_RptThuyetMinhChiPhi);
                    return this.m_Frm_RptThuyetMinhChiPhi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptThuyetMinhChiPhi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptThuyetMinhChiPhi>(ref this.m_Frm_RptThuyetMinhChiPhi);
                    }
                }
            }

            public ACCOUNTING.Frm_RptTongHopHangHoaMuaVao Frm_RptTongHopHangHoaMuaVao
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptTongHopHangHoaMuaVao = Create__Instance__<ACCOUNTING.Frm_RptTongHopHangHoaMuaVao>(this.m_Frm_RptTongHopHangHoaMuaVao);
                    return this.m_Frm_RptTongHopHangHoaMuaVao;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptTongHopHangHoaMuaVao)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptTongHopHangHoaMuaVao>(ref this.m_Frm_RptTongHopHangHoaMuaVao);
                    }
                }
            }

            public ACCOUNTING.Frm_RptXuatChuyenKhoList Frm_RptXuatChuyenKhoList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RptXuatChuyenKhoList = Create__Instance__<ACCOUNTING.Frm_RptXuatChuyenKhoList>(this.m_Frm_RptXuatChuyenKhoList);
                    return this.m_Frm_RptXuatChuyenKhoList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RptXuatChuyenKhoList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RptXuatChuyenKhoList>(ref this.m_Frm_RptXuatChuyenKhoList);
                    }
                }
            }

            public ACCOUNTING.Frm_Run Frm_Run
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_Run = Create__Instance__<ACCOUNTING.Frm_Run>(this.m_Frm_Run);
                    return this.m_Frm_Run;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_Run)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_Run>(ref this.m_Frm_Run);
                    }
                }
            }

            public ACCOUNTING.Frm_RunSQL Frm_RunSQL
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_RunSQL = Create__Instance__<ACCOUNTING.Frm_RunSQL>(this.m_Frm_RunSQL);
                    return this.m_Frm_RunSQL;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_RunSQL)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_RunSQL>(ref this.m_Frm_RunSQL);
                    }
                }
            }

            public ACCOUNTING.Frm_SaleOrder Frm_SaleOrder
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SaleOrder = Create__Instance__<ACCOUNTING.Frm_SaleOrder>(this.m_Frm_SaleOrder);
                    return this.m_Frm_SaleOrder;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SaleOrder)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SaleOrder>(ref this.m_Frm_SaleOrder);
                    }
                }
            }

            public ACCOUNTING.Frm_SanPhamDoDang Frm_SanPhamDoDang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SanPhamDoDang = Create__Instance__<ACCOUNTING.Frm_SanPhamDoDang>(this.m_Frm_SanPhamDoDang);
                    return this.m_Frm_SanPhamDoDang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SanPhamDoDang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SanPhamDoDang>(ref this.m_Frm_SanPhamDoDang);
                    }
                }
            }

            public ACCOUNTING.Frm_SearchTaiSanCoDinh Frm_SearchTaiSanCoDinh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SearchTaiSanCoDinh = Create__Instance__<ACCOUNTING.Frm_SearchTaiSanCoDinh>(this.m_Frm_SearchTaiSanCoDinh);
                    return this.m_Frm_SearchTaiSanCoDinh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SearchTaiSanCoDinh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SearchTaiSanCoDinh>(ref this.m_Frm_SearchTaiSanCoDinh);
                    }
                }
            }

            public ACCOUNTING.Frm_SoCaiChiTietTaiKhoan Frm_SoCaiChiTietTaiKhoan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SoCaiChiTietTaiKhoan = Create__Instance__<ACCOUNTING.Frm_SoCaiChiTietTaiKhoan>(this.m_Frm_SoCaiChiTietTaiKhoan);
                    return this.m_Frm_SoCaiChiTietTaiKhoan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SoCaiChiTietTaiKhoan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SoCaiChiTietTaiKhoan>(ref this.m_Frm_SoCaiChiTietTaiKhoan);
                    }
                }
            }

            public ACCOUNTING.Frm_SoDuDauKy Frm_SoDuDauKy
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SoDuDauKy = Create__Instance__<ACCOUNTING.Frm_SoDuDauKy>(this.m_Frm_SoDuDauKy);
                    return this.m_Frm_SoDuDauKy;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SoDuDauKy)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SoDuDauKy>(ref this.m_Frm_SoDuDauKy);
                    }
                }
            }

            public ACCOUNTING.Frm_SoDuDauKyCongNo Frm_SoDuDauKyCongNo
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SoDuDauKyCongNo = Create__Instance__<ACCOUNTING.Frm_SoDuDauKyCongNo>(this.m_Frm_SoDuDauKyCongNo);
                    return this.m_Frm_SoDuDauKyCongNo;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SoDuDauKyCongNo)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SoDuDauKyCongNo>(ref this.m_Frm_SoDuDauKyCongNo);
                    }
                }
            }

            public ACCOUNTING.Frm_SoDuDauKyHangHoa Frm_SoDuDauKyHangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SoDuDauKyHangHoa = Create__Instance__<ACCOUNTING.Frm_SoDuDauKyHangHoa>(this.m_Frm_SoDuDauKyHangHoa);
                    return this.m_Frm_SoDuDauKyHangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SoDuDauKyHangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SoDuDauKyHangHoa>(ref this.m_Frm_SoDuDauKyHangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_SoDuDauKyTaiSan Frm_SoDuDauKyTaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SoDuDauKyTaiSan = Create__Instance__<ACCOUNTING.Frm_SoDuDauKyTaiSan>(this.m_Frm_SoDuDauKyTaiSan);
                    return this.m_Frm_SoDuDauKyTaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SoDuDauKyTaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SoDuDauKyTaiSan>(ref this.m_Frm_SoDuDauKyTaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_SoNhatKyChung Frm_SoNhatKyChung
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SoNhatKyChung = Create__Instance__<ACCOUNTING.Frm_SoNhatKyChung>(this.m_Frm_SoNhatKyChung);
                    return this.m_Frm_SoNhatKyChung;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SoNhatKyChung)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SoNhatKyChung>(ref this.m_Frm_SoNhatKyChung);
                    }
                }
            }

            public ACCOUNTING.Frm_SoSuaChua Frm_SoSuaChua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SoSuaChua = Create__Instance__<ACCOUNTING.Frm_SoSuaChua>(this.m_Frm_SoSuaChua);
                    return this.m_Frm_SoSuaChua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SoSuaChua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SoSuaChua>(ref this.m_Frm_SoSuaChua);
                    }
                }
            }

            public ACCOUNTING.Frm_SplashScreen Frm_SplashScreen
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_SplashScreen = Create__Instance__<ACCOUNTING.Frm_SplashScreen>(this.m_Frm_SplashScreen);
                    return this.m_Frm_SplashScreen;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_SplashScreen)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_SplashScreen>(ref this.m_Frm_SplashScreen);
                    }
                }
            }

            public ACCOUNTING.Frm_TaiKhoanChiPhiTraTruoc Frm_TaiKhoanChiPhiTraTruoc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TaiKhoanChiPhiTraTruoc = Create__Instance__<ACCOUNTING.Frm_TaiKhoanChiPhiTraTruoc>(this.m_Frm_TaiKhoanChiPhiTraTruoc);
                    return this.m_Frm_TaiKhoanChiPhiTraTruoc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TaiKhoanChiPhiTraTruoc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TaiKhoanChiPhiTraTruoc>(ref this.m_Frm_TaiKhoanChiPhiTraTruoc);
                    }
                }
            }

            public ACCOUNTING.Frm_TaiSan Frm_TaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TaiSan = Create__Instance__<ACCOUNTING.Frm_TaiSan>(this.m_Frm_TaiSan);
                    return this.m_Frm_TaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TaiSan>(ref this.m_Frm_TaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_TamUng Frm_TamUng
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TamUng = Create__Instance__<ACCOUNTING.Frm_TamUng>(this.m_Frm_TamUng);
                    return this.m_Frm_TamUng;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TamUng)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TamUng>(ref this.m_Frm_TamUng);
                    }
                }
            }

            public ACCOUNTING.Frm_TangTaiSan Frm_TangTaiSan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TangTaiSan = Create__Instance__<ACCOUNTING.Frm_TangTaiSan>(this.m_Frm_TangTaiSan);
                    return this.m_Frm_TangTaiSan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TangTaiSan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TangTaiSan>(ref this.m_Frm_TangTaiSan);
                    }
                }
            }

            public ACCOUNTING.Frm_TangTaiSanList Frm_TangTaiSanList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TangTaiSanList = Create__Instance__<ACCOUNTING.Frm_TangTaiSanList>(this.m_Frm_TangTaiSanList);
                    return this.m_Frm_TangTaiSanList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TangTaiSanList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TangTaiSanList>(ref this.m_Frm_TangTaiSanList);
                    }
                }
            }

            public ACCOUNTING.Frm_TaoDuLieuMoi Frm_TaoDuLieuMoi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TaoDuLieuMoi = Create__Instance__<ACCOUNTING.Frm_TaoDuLieuMoi>(this.m_Frm_TaoDuLieuMoi);
                    return this.m_Frm_TaoDuLieuMoi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TaoDuLieuMoi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TaoDuLieuMoi>(ref this.m_Frm_TaoDuLieuMoi);
                    }
                }
            }

            public ACCOUNTING.Frm_ThanhToan Frm_ThanhToan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThanhToan = Create__Instance__<ACCOUNTING.Frm_ThanhToan>(this.m_Frm_ThanhToan);
                    return this.m_Frm_ThanhToan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThanhToan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThanhToan>(ref this.m_Frm_ThanhToan);
                    }
                }
            }

            public ACCOUNTING.Frm_ThanhToanDauVao Frm_ThanhToanDauVao
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThanhToanDauVao = Create__Instance__<ACCOUNTING.Frm_ThanhToanDauVao>(this.m_Frm_ThanhToanDauVao);
                    return this.m_Frm_ThanhToanDauVao;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThanhToanDauVao)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThanhToanDauVao>(ref this.m_Frm_ThanhToanDauVao);
                    }
                }
            }

            public ACCOUNTING.Frm_ThanhToanNhaCungCap Frm_ThanhToanNhaCungCap
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThanhToanNhaCungCap = Create__Instance__<ACCOUNTING.Frm_ThanhToanNhaCungCap>(this.m_Frm_ThanhToanNhaCungCap);
                    return this.m_Frm_ThanhToanNhaCungCap;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThanhToanNhaCungCap)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThanhToanNhaCungCap>(ref this.m_Frm_ThanhToanNhaCungCap);
                    }
                }
            }

            public ACCOUNTING.Frm_ThanhToanNhaCungCapList Frm_ThanhToanNhaCungCapList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThanhToanNhaCungCapList = Create__Instance__<ACCOUNTING.Frm_ThanhToanNhaCungCapList>(this.m_Frm_ThanhToanNhaCungCapList);
                    return this.m_Frm_ThanhToanNhaCungCapList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThanhToanNhaCungCapList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThanhToanNhaCungCapList>(ref this.m_Frm_ThanhToanNhaCungCapList);
                    }
                }
            }

            public ACCOUNTING.Frm_TheKhoVatTu Frm_TheKhoVatTu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TheKhoVatTu = Create__Instance__<ACCOUNTING.Frm_TheKhoVatTu>(this.m_Frm_TheKhoVatTu);
                    return this.m_Frm_TheKhoVatTu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TheKhoVatTu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TheKhoVatTu>(ref this.m_Frm_TheKhoVatTu);
                    }
                }
            }

            public ACCOUNTING.Frm_ThemKiHieu Frm_ThemKiHieu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThemKiHieu = Create__Instance__<ACCOUNTING.Frm_ThemKiHieu>(this.m_Frm_ThemKiHieu);
                    return this.m_Frm_ThemKiHieu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThemKiHieu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThemKiHieu>(ref this.m_Frm_ThemKiHieu);
                    }
                }
            }

            public ACCOUNTING.Frm_ThietLapHoaDon Frm_ThietLapHoaDon
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThietLapHoaDon = Create__Instance__<ACCOUNTING.Frm_ThietLapHoaDon>(this.m_Frm_ThietLapHoaDon);
                    return this.m_Frm_ThietLapHoaDon;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThietLapHoaDon)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThietLapHoaDon>(ref this.m_Frm_ThietLapHoaDon);
                    }
                }
            }

            public ACCOUNTING.Frm_ThongSo Frm_ThongSo
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThongSo = Create__Instance__<ACCOUNTING.Frm_ThongSo>(this.m_Frm_ThongSo);
                    return this.m_Frm_ThongSo;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThongSo)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThongSo>(ref this.m_Frm_ThongSo);
                    }
                }
            }

            public ACCOUNTING.Frm_ThongTinCongTy Frm_ThongTinCongTy
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThongTinCongTy = Create__Instance__<ACCOUNTING.Frm_ThongTinCongTy>(this.m_Frm_ThongTinCongTy);
                    return this.m_Frm_ThongTinCongTy;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThongTinCongTy)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThongTinCongTy>(ref this.m_Frm_ThongTinCongTy);
                    }
                }
            }

            public ACCOUNTING.Frm_ThongTinPhanMem Frm_ThongTinPhanMem
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThongTinPhanMem = Create__Instance__<ACCOUNTING.Frm_ThongTinPhanMem>(this.m_Frm_ThongTinPhanMem);
                    return this.m_Frm_ThongTinPhanMem;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThongTinPhanMem)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThongTinPhanMem>(ref this.m_Frm_ThongTinPhanMem);
                    }
                }
            }

            public ACCOUNTING.Frm_ThongTinThemChuyenDiaDiem Frm_ThongTinThemChuyenDiaDiem
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThongTinThemChuyenDiaDiem = Create__Instance__<ACCOUNTING.Frm_ThongTinThemChuyenDiaDiem>(this.m_Frm_ThongTinThemChuyenDiaDiem);
                    return this.m_Frm_ThongTinThemChuyenDiaDiem;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThongTinThemChuyenDiaDiem)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThongTinThemChuyenDiaDiem>(ref this.m_Frm_ThongTinThemChuyenDiaDiem);
                    }
                }
            }

            public ACCOUNTING.Frm_ThongTinThemPhatHanhHoaDon Frm_ThongTinThemPhatHanhHoaDon
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThongTinThemPhatHanhHoaDon = Create__Instance__<ACCOUNTING.Frm_ThongTinThemPhatHanhHoaDon>(this.m_Frm_ThongTinThemPhatHanhHoaDon);
                    return this.m_Frm_ThongTinThemPhatHanhHoaDon;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThongTinThemPhatHanhHoaDon)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThongTinThemPhatHanhHoaDon>(ref this.m_Frm_ThongTinThemPhatHanhHoaDon);
                    }
                }
            }

            public ACCOUNTING.Frm_ThuTienBanHangList Frm_ThuTienBanHangList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ThuTienBanHangList = Create__Instance__<ACCOUNTING.Frm_ThuTienBanHangList>(this.m_Frm_ThuTienBanHangList);
                    return this.m_Frm_ThuTienBanHangList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ThuTienBanHangList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ThuTienBanHangList>(ref this.m_Frm_ThuTienBanHangList);
                    }
                }
            }

            public ACCOUNTING.Frm_TiepNhanList Frm_TiepNhanList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TiepNhanList = Create__Instance__<ACCOUNTING.Frm_TiepNhanList>(this.m_Frm_TiepNhanList);
                    return this.m_Frm_TiepNhanList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TiepNhanList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TiepNhanList>(ref this.m_Frm_TiepNhanList);
                    }
                }
            }

            public ACCOUNTING.Frm_TiepNhanThietBi Frm_TiepNhanThietBi
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TiepNhanThietBi = Create__Instance__<ACCOUNTING.Frm_TiepNhanThietBi>(this.m_Frm_TiepNhanThietBi);
                    return this.m_Frm_TiepNhanThietBi;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TiepNhanThietBi)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TiepNhanThietBi>(ref this.m_Frm_TiepNhanThietBi);
                    }
                }
            }

            public ACCOUNTING.Frm_TimDanhMuc Frm_TimDanhMuc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimDanhMuc = Create__Instance__<ACCOUNTING.Frm_TimDanhMuc>(this.m_Frm_TimDanhMuc);
                    return this.m_Frm_TimDanhMuc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimDanhMuc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimDanhMuc>(ref this.m_Frm_TimDanhMuc);
                    }
                }
            }

            public ACCOUNTING.Frm_TimDoiTuong Frm_TimDoiTuong
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimDoiTuong = Create__Instance__<ACCOUNTING.Frm_TimDoiTuong>(this.m_Frm_TimDoiTuong);
                    return this.m_Frm_TimDoiTuong;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimDoiTuong)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimDoiTuong>(ref this.m_Frm_TimDoiTuong);
                    }
                }
            }

            public ACCOUNTING.Frm_TimHangHoa Frm_TimHangHoa
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimHangHoa = Create__Instance__<ACCOUNTING.Frm_TimHangHoa>(this.m_Frm_TimHangHoa);
                    return this.m_Frm_TimHangHoa;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimHangHoa)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimHangHoa>(ref this.m_Frm_TimHangHoa);
                    }
                }
            }

            public ACCOUNTING.Frm_TimThanhPham Frm_TimThanhPham
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimThanhPham = Create__Instance__<ACCOUNTING.Frm_TimThanhPham>(this.m_Frm_TimThanhPham);
                    return this.m_Frm_TimThanhPham;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimThanhPham)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimThanhPham>(ref this.m_Frm_TimThanhPham);
                    }
                }
            }

            public ACCOUNTING.Frm_TimHangTonKho Frm_TimHangTonKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimHangTonKho = Create__Instance__<ACCOUNTING.Frm_TimHangTonKho>(this.m_Frm_TimHangTonKho);
                    return this.m_Frm_TimHangTonKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimHangTonKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimHangTonKho>(ref this.m_Frm_TimHangTonKho);
                    }
                }
            }

            public ACCOUNTING.Frm_TimPhieuBanHang Frm_TimPhieuBanHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimPhieuBanHang = Create__Instance__<ACCOUNTING.Frm_TimPhieuBanHang>(this.m_Frm_TimPhieuBanHang);
                    return this.m_Frm_TimPhieuBanHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimPhieuBanHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimPhieuBanHang>(ref this.m_Frm_TimPhieuBanHang);
                    }
                }
            }

            public ACCOUNTING.Frm_TimPhieuChiTienThua Frm_TimPhieuChiTienThua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimPhieuChiTienThua = Create__Instance__<ACCOUNTING.Frm_TimPhieuChiTienThua>(this.m_Frm_TimPhieuChiTienThua);
                    return this.m_Frm_TimPhieuChiTienThua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimPhieuChiTienThua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimPhieuChiTienThua>(ref this.m_Frm_TimPhieuChiTienThua);
                    }
                }
            }

            public ACCOUNTING.Frm_TimPhieuMuaHangNuocNgoai Frm_TimPhieuMuaHangNuocNgoai
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimPhieuMuaHangNuocNgoai = Create__Instance__<ACCOUNTING.Frm_TimPhieuMuaHangNuocNgoai>(this.m_Frm_TimPhieuMuaHangNuocNgoai);
                    return this.m_Frm_TimPhieuMuaHangNuocNgoai;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimPhieuMuaHangNuocNgoai)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimPhieuMuaHangNuocNgoai>(ref this.m_Frm_TimPhieuMuaHangNuocNgoai);
                    }
                }
            }

            public ACCOUNTING.Frm_TimPhieuMuaHangTrongNuoc Frm_TimPhieuMuaHangTrongNuoc
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimPhieuMuaHangTrongNuoc = Create__Instance__<ACCOUNTING.Frm_TimPhieuMuaHangTrongNuoc>(this.m_Frm_TimPhieuMuaHangTrongNuoc);
                    return this.m_Frm_TimPhieuMuaHangTrongNuoc;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimPhieuMuaHangTrongNuoc)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimPhieuMuaHangTrongNuoc>(ref this.m_Frm_TimPhieuMuaHangTrongNuoc);
                    }
                }
            }

            public ACCOUNTING.Frm_TimPhieuThuTienThua Frm_TimPhieuThuTienThua
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimPhieuThuTienThua = Create__Instance__<ACCOUNTING.Frm_TimPhieuThuTienThua>(this.m_Frm_TimPhieuThuTienThua);
                    return this.m_Frm_TimPhieuThuTienThua;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimPhieuThuTienThua)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimPhieuThuTienThua>(ref this.m_Frm_TimPhieuThuTienThua);
                    }
                }
            }

            public ACCOUNTING.Frm_TimQuocGia Frm_TimQuocGia
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TimQuocGia = Create__Instance__<ACCOUNTING.Frm_TimQuocGia>(this.m_Frm_TimQuocGia);
                    return this.m_Frm_TimQuocGia;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TimQuocGia)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TimQuocGia>(ref this.m_Frm_TimQuocGia);
                    }
                }
            }

            public ACCOUNTING.Frm_TinhChiPhiBanHang Frm_TinhChiPhiBanHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TinhChiPhiBanHang = Create__Instance__<ACCOUNTING.Frm_TinhChiPhiBanHang>(this.m_Frm_TinhChiPhiBanHang);
                    return this.m_Frm_TinhChiPhiBanHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TinhChiPhiBanHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TinhChiPhiBanHang>(ref this.m_Frm_TinhChiPhiBanHang);
                    }
                }
            }

            public ACCOUNTING.Frm_TinhHoaHong Frm_TinhHoaHong
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TinhHoaHong = Create__Instance__<ACCOUNTING.Frm_TinhHoaHong>(this.m_Frm_TinhHoaHong);
                    return this.m_Frm_TinhHoaHong;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TinhHoaHong)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TinhHoaHong>(ref this.m_Frm_TinhHoaHong);
                    }
                }
            }

            public ACCOUNTING.Frm_TongHop Frm_TongHop
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TongHop = Create__Instance__<ACCOUNTING.Frm_TongHop>(this.m_Frm_TongHop);
                    return this.m_Frm_TongHop;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TongHop)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TongHop>(ref this.m_Frm_TongHop);
                    }
                }
            }

            public ACCOUNTING.Frm_TongHopHangTonKho Frm_TongHopHangTonKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TongHopHangTonKho = Create__Instance__<ACCOUNTING.Frm_TongHopHangTonKho>(this.m_Frm_TongHopHangTonKho);
                    return this.m_Frm_TongHopHangTonKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TongHopHangTonKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TongHopHangTonKho>(ref this.m_Frm_TongHopHangTonKho);
                    }
                }
            }

            public ACCOUNTING.Frm_TongHopList Frm_TongHopList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TongHopList = Create__Instance__<ACCOUNTING.Frm_TongHopList>(this.m_Frm_TongHopList);
                    return this.m_Frm_TongHopList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TongHopList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TongHopList>(ref this.m_Frm_TongHopList);
                    }
                }
            }

            public ACCOUNTING.Frm_TongHopThanhToanTienHang Frm_TongHopThanhToanTienHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TongHopThanhToanTienHang = Create__Instance__<ACCOUNTING.Frm_TongHopThanhToanTienHang>(this.m_Frm_TongHopThanhToanTienHang);
                    return this.m_Frm_TongHopThanhToanTienHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TongHopThanhToanTienHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TongHopThanhToanTienHang>(ref this.m_Frm_TongHopThanhToanTienHang);
                    }
                }
            }

            public ACCOUNTING.Frm_TongHopThuTienBanHang Frm_TongHopThuTienBanHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TongHopThuTienBanHang = Create__Instance__<ACCOUNTING.Frm_TongHopThuTienBanHang>(this.m_Frm_TongHopThuTienBanHang);
                    return this.m_Frm_TongHopThuTienBanHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TongHopThuTienBanHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TongHopThuTienBanHang>(ref this.m_Frm_TongHopThuTienBanHang);
                    }
                }
            }

            public ACCOUNTING.Frm_TraCuuQuaTrinhNhapXuat Frm_TraCuuQuaTrinhNhapXuat
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TraCuuQuaTrinhNhapXuat = Create__Instance__<ACCOUNTING.Frm_TraCuuQuaTrinhNhapXuat>(this.m_Frm_TraCuuQuaTrinhNhapXuat);
                    return this.m_Frm_TraCuuQuaTrinhNhapXuat;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TraCuuQuaTrinhNhapXuat)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TraCuuQuaTrinhNhapXuat>(ref this.m_Frm_TraCuuQuaTrinhNhapXuat);
                    }
                }
            }

            public ACCOUNTING.Frm_TraHangNhaCungCap Frm_TraHangNhaCungCap
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TraHangNhaCungCap = Create__Instance__<ACCOUNTING.Frm_TraHangNhaCungCap>(this.m_Frm_TraHangNhaCungCap);
                    return this.m_Frm_TraHangNhaCungCap;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TraHangNhaCungCap)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TraHangNhaCungCap>(ref this.m_Frm_TraHangNhaCungCap);
                    }
                }
            }

            public ACCOUNTING.Frm_TraHangNhaCungCapList Frm_TraHangNhaCungCapList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TraHangNhaCungCapList = Create__Instance__<ACCOUNTING.Frm_TraHangNhaCungCapList>(this.m_Frm_TraHangNhaCungCapList);
                    return this.m_Frm_TraHangNhaCungCapList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TraHangNhaCungCapList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TraHangNhaCungCapList>(ref this.m_Frm_TraHangNhaCungCapList);
                    }
                }
            }

            public ACCOUNTING.Frm_TranferData Frm_TranferData
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TranferData = Create__Instance__<ACCOUNTING.Frm_TranferData>(this.m_Frm_TranferData);
                    return this.m_Frm_TranferData;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TranferData)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TranferData>(ref this.m_Frm_TranferData);
                    }
                }
            }

            public ACCOUNTING.Frm_TraTruocNguoiBan Frm_TraTruocNguoiBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TraTruocNguoiBan = Create__Instance__<ACCOUNTING.Frm_TraTruocNguoiBan>(this.m_Frm_TraTruocNguoiBan);
                    return this.m_Frm_TraTruocNguoiBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TraTruocNguoiBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TraTruocNguoiBan>(ref this.m_Frm_TraTruocNguoiBan);
                    }
                }
            }

            public ACCOUNTING.Frm_TraTruocNguoiBanList Frm_TraTruocNguoiBanList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TraTruocNguoiBanList = Create__Instance__<ACCOUNTING.Frm_TraTruocNguoiBanList>(this.m_Frm_TraTruocNguoiBanList);
                    return this.m_Frm_TraTruocNguoiBanList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TraTruocNguoiBanList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TraTruocNguoiBanList>(ref this.m_Frm_TraTruocNguoiBanList);
                    }
                }
            }

            public ACCOUNTING.Frm_TruyVanBanHang Frm_TruyVanBanHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TruyVanBanHang = Create__Instance__<ACCOUNTING.Frm_TruyVanBanHang>(this.m_Frm_TruyVanBanHang);
                    return this.m_Frm_TruyVanBanHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TruyVanBanHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TruyVanBanHang>(ref this.m_Frm_TruyVanBanHang);
                    }
                }
            }

            public ACCOUNTING.Frm_TruyVanCongNoPhaiThu Frm_TruyVanCongNoPhaiThu
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TruyVanCongNoPhaiThu = Create__Instance__<ACCOUNTING.Frm_TruyVanCongNoPhaiThu>(this.m_Frm_TruyVanCongNoPhaiThu);
                    return this.m_Frm_TruyVanCongNoPhaiThu;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TruyVanCongNoPhaiThu)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TruyVanCongNoPhaiThu>(ref this.m_Frm_TruyVanCongNoPhaiThu);
                    }
                }
            }

            public ACCOUNTING.Frm_TruyVanCongNoPhaiTra Frm_TruyVanCongNoPhaiTra
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TruyVanCongNoPhaiTra = Create__Instance__<ACCOUNTING.Frm_TruyVanCongNoPhaiTra>(this.m_Frm_TruyVanCongNoPhaiTra);
                    return this.m_Frm_TruyVanCongNoPhaiTra;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TruyVanCongNoPhaiTra)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TruyVanCongNoPhaiTra>(ref this.m_Frm_TruyVanCongNoPhaiTra);
                    }
                }
            }

            public ACCOUNTING.Frm_TruyVanHangTonKho Frm_TruyVanHangTonKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TruyVanHangTonKho = Create__Instance__<ACCOUNTING.Frm_TruyVanHangTonKho>(this.m_Frm_TruyVanHangTonKho);
                    return this.m_Frm_TruyVanHangTonKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TruyVanHangTonKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TruyVanHangTonKho>(ref this.m_Frm_TruyVanHangTonKho);
                    }
                }
            }

            public ACCOUNTING.Frm_TSCD Frm_TSCD
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TSCD = Create__Instance__<ACCOUNTING.Frm_TSCD>(this.m_Frm_TSCD);
                    return this.m_Frm_TSCD;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TSCD)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TSCD>(ref this.m_Frm_TSCD);
                    }
                }
            }

            public ACCOUNTING.Frm_TuyChonInBaoGia Frm_TuyChonInBaoGia
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_TuyChonInBaoGia = Create__Instance__<ACCOUNTING.Frm_TuyChonInBaoGia>(this.m_Frm_TuyChonInBaoGia);
                    return this.m_Frm_TuyChonInBaoGia;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_TuyChonInBaoGia)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_TuyChonInBaoGia>(ref this.m_Frm_TuyChonInBaoGia);
                    }
                }
            }

            public ACCOUNTING.Frm_ViewReport Frm_ViewReport
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ViewReport = Create__Instance__<ACCOUNTING.Frm_ViewReport>(this.m_Frm_ViewReport);
                    return this.m_Frm_ViewReport;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ViewReport)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ViewReport>(ref this.m_Frm_ViewReport);
                    }
                }
            }

            public ACCOUNTING.Frm_ViewReport2 Frm_ViewReport2
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_ViewReport2 = Create__Instance__<ACCOUNTING.Frm_ViewReport2>(this.m_Frm_ViewReport2);
                    return this.m_Frm_ViewReport2;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_ViewReport2)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_ViewReport2>(ref this.m_Frm_ViewReport2);
                    }
                }
            }

            public ACCOUNTING.Frm_VonBangTien Frm_VonBangTien
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_VonBangTien = Create__Instance__<ACCOUNTING.Frm_VonBangTien>(this.m_Frm_VonBangTien);
                    return this.m_Frm_VonBangTien;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_VonBangTien)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_VonBangTien>(ref this.m_Frm_VonBangTien);
                    }
                }
            }

            public ACCOUNTING.Frm_XacDinhSanPhanHoanThanh Frm_XacDinhSanPhanHoanThanh
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XacDinhSanPhanHoanThanh = Create__Instance__<ACCOUNTING.Frm_XacDinhSanPhanHoanThanh>(this.m_Frm_XacDinhSanPhanHoanThanh);
                    return this.m_Frm_XacDinhSanPhanHoanThanh;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XacDinhSanPhanHoanThanh)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XacDinhSanPhanHoanThanh>(ref this.m_Frm_XacDinhSanPhanHoanThanh);
                    }
                }
            }

            public ACCOUNTING.Frm_XacNhanDonHang Frm_XacNhanDonHang
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XacNhanDonHang = Create__Instance__<ACCOUNTING.Frm_XacNhanDonHang>(this.m_Frm_XacNhanDonHang);
                    return this.m_Frm_XacNhanDonHang;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XacNhanDonHang)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XacNhanDonHang>(ref this.m_Frm_XacNhanDonHang);
                    }
                }
            }

            public ACCOUNTING.Frm_XacNhanDonHangBan Frm_XacNhanDonHangBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XacNhanDonHangBan = Create__Instance__<ACCOUNTING.Frm_XacNhanDonHangBan>(this.m_Frm_XacNhanDonHangBan);
                    return this.m_Frm_XacNhanDonHangBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XacNhanDonHangBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XacNhanDonHangBan>(ref this.m_Frm_XacNhanDonHangBan);
                    }
                }
            }

            public ACCOUNTING.Frm_XacNhanThanhToanDauVao Frm_XacNhanThanhToanDauVao
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XacNhanThanhToanDauVao = Create__Instance__<ACCOUNTING.Frm_XacNhanThanhToanDauVao>(this.m_Frm_XacNhanThanhToanDauVao);
                    return this.m_Frm_XacNhanThanhToanDauVao;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XacNhanThanhToanDauVao)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XacNhanThanhToanDauVao>(ref this.m_Frm_XacNhanThanhToanDauVao);
                    }
                }
            }

            public ACCOUNTING.Frm_XacNhanThanhToanHoaDon Frm_XacNhanThanhToanHoaDon
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XacNhanThanhToanHoaDon = Create__Instance__<ACCOUNTING.Frm_XacNhanThanhToanHoaDon>(this.m_Frm_XacNhanThanhToanHoaDon);
                    return this.m_Frm_XacNhanThanhToanHoaDon;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XacNhanThanhToanHoaDon)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XacNhanThanhToanHoaDon>(ref this.m_Frm_XacNhanThanhToanHoaDon);
                    }
                }
            }

            public ACCOUNTING.Frm_XemDinhKhoan Frm_XemDinhKhoan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XemDinhKhoan = Create__Instance__<ACCOUNTING.Frm_XemDinhKhoan>(this.m_Frm_XemDinhKhoan);
                    return this.m_Frm_XemDinhKhoan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XemDinhKhoan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XemDinhKhoan>(ref this.m_Frm_XemDinhKhoan);
                    }
                }
            }

            public ACCOUNTING.Frm_XuatBan Frm_XuatBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XuatBan = Create__Instance__<ACCOUNTING.Frm_XuatBan>(this.m_Frm_XuatBan);
                    return this.m_Frm_XuatBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XuatBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XuatBan>(ref this.m_Frm_XuatBan);
                    }
                }
            }

            public ACCOUNTING.Frm_XuatBanList Frm_XuatBanList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XuatBanList = Create__Instance__<ACCOUNTING.Frm_XuatBanList>(this.m_Frm_XuatBanList);
                    return this.m_Frm_XuatBanList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XuatBanList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XuatBanList>(ref this.m_Frm_XuatBanList);
                    }
                }
            }

            public ACCOUNTING.Frm_XuatChuyen Frm_XuatChuyen
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XuatChuyen = Create__Instance__<ACCOUNTING.Frm_XuatChuyen>(this.m_Frm_XuatChuyen);
                    return this.m_Frm_XuatChuyen;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XuatChuyen)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XuatChuyen>(ref this.m_Frm_XuatChuyen);
                    }
                }
            }

            public ACCOUNTING.Frm_XuatChuyenKhoList Frm_XuatChuyenKhoList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XuatChuyenKhoList = Create__Instance__<ACCOUNTING.Frm_XuatChuyenKhoList>(this.m_Frm_XuatChuyenKhoList);
                    return this.m_Frm_XuatChuyenKhoList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XuatChuyenKhoList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XuatChuyenKhoList>(ref this.m_Frm_XuatChuyenKhoList);
                    }
                }
            }

            public ACCOUNTING.Frm_XuatKho Frm_XuatKho
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XuatKho = Create__Instance__<ACCOUNTING.Frm_XuatKho>(this.m_Frm_XuatKho);
                    return this.m_Frm_XuatKho;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XuatKho)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XuatKho>(ref this.m_Frm_XuatKho);
                    }
                }
            }

            public ACCOUNTING.Frm_XuatKhoList Frm_XuatKhoList
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_XuatKhoList = Create__Instance__<ACCOUNTING.Frm_XuatKhoList>(this.m_Frm_XuatKhoList);
                    return this.m_Frm_XuatKhoList;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_XuatKhoList)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_XuatKhoList>(ref this.m_Frm_XuatKhoList);
                    }
                }
            }

            public ACCOUNTING.Frm_YeuCauBaoGia Frm_YeuCauBaoGia
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_Frm_YeuCauBaoGia = Create__Instance__<ACCOUNTING.Frm_YeuCauBaoGia>(this.m_Frm_YeuCauBaoGia);
                    return this.m_Frm_YeuCauBaoGia;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_Frm_YeuCauBaoGia)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.Frm_YeuCauBaoGia>(ref this.m_Frm_YeuCauBaoGia);
                    }
                }
            }

            public ACCOUNTING.FRMMAIN FRMMAIN
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_FRMMAIN = Create__Instance__<ACCOUNTING.FRMMAIN>(this.m_FRMMAIN);
                    return this.m_FRMMAIN;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_FRMMAIN)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.FRMMAIN>(ref this.m_FRMMAIN);
                    }
                }
            }

            public ACCOUNTING.FrmTimKhachHangTamUng FrmTimKhachHangTamUng
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_FrmTimKhachHangTamUng = Create__Instance__<ACCOUNTING.FrmTimKhachHangTamUng>(this.m_FrmTimKhachHangTamUng);
                    return this.m_FrmTimKhachHangTamUng;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_FrmTimKhachHangTamUng)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.FrmTimKhachHangTamUng>(ref this.m_FrmTimKhachHangTamUng);
                    }
                }
            }

            public ACCOUNTING.FrmTimTraTruocNguoiBan FrmTimTraTruocNguoiBan
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_FrmTimTraTruocNguoiBan = Create__Instance__<ACCOUNTING.FrmTimTraTruocNguoiBan>(this.m_FrmTimTraTruocNguoiBan);
                    return this.m_FrmTimTraTruocNguoiBan;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_FrmTimTraTruocNguoiBan)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.FrmTimTraTruocNguoiBan>(ref this.m_FrmTimTraTruocNguoiBan);
                    }
                }
            }

            public ACCOUNTING.MultiColumnDropDown MultiColumnDropDown
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_MultiColumnDropDown = Create__Instance__<ACCOUNTING.MultiColumnDropDown>(this.m_MultiColumnDropDown);
                    return this.m_MultiColumnDropDown;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_MultiColumnDropDown)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.MultiColumnDropDown>(ref this.m_MultiColumnDropDown);
                    }
                }
            }

            public ACCOUNTING.PopupDropDown PopupDropDown
            {
                [DebuggerNonUserCode]
                get
                {
                    this.m_PopupDropDown = Create__Instance__<ACCOUNTING.PopupDropDown>(this.m_PopupDropDown);
                    return this.m_PopupDropDown;
                }
                [DebuggerNonUserCode]
                set
                {
                    if (value != this.m_PopupDropDown)
                    {
                        if (value != null)
                        {
                            throw new ArgumentException("Property can only be set to Nothing");
                        }
                        this.Dispose__Instance__<ACCOUNTING.PopupDropDown>(ref this.m_PopupDropDown);
                    }
                }
            }
        }

        [MyGroupCollection("System.Web.Services.Protocols.SoapHttpClientProtocol", "Create__Instance__", "Dispose__Instance__", ""), EditorBrowsable(EditorBrowsableState.Never)]
        internal sealed class MyWebServices
        {
            [DebuggerHidden]
            private static T Create__Instance__<T>(T instance) where T: new()
            {
                if (instance == null)
                {
                    return Activator.CreateInstance<T>();
                }
                return instance;
            }

            [DebuggerHidden]
            private void Dispose__Instance__<T>(ref T instance)
            {
                instance = default(T);
            }

            [DebuggerHidden, EditorBrowsable(EditorBrowsableState.Never)]
            public override bool Equals(object o)
            {
                return base.Equals(RuntimeHelpers.GetObjectValue(o));
            }

            [EditorBrowsable(EditorBrowsableState.Never), DebuggerHidden]
            public override int GetHashCode()
            {
                return base.GetHashCode();
            }

            [DebuggerHidden, EditorBrowsable(EditorBrowsableState.Never)]
            internal Type GetType()
            {
                return typeof(MyProject.MyWebServices);
            }

            [EditorBrowsable(EditorBrowsableState.Never), DebuggerHidden]
            public override string ToString()
            {
                return base.ToString();
            }
        }

        [EditorBrowsable(EditorBrowsableState.Never), ComVisible(false)]
        internal sealed class ThreadSafeObjectProvider<T> where T: new()
        {
            [ThreadStatic, CompilerGenerated]
            private static T m_ThreadStaticValue;

            internal T GetInstance
            {
                [DebuggerHidden]
                get
                {
                    if (MyProject.ThreadSafeObjectProvider<T>.m_ThreadStaticValue == null)
                    {
                        MyProject.ThreadSafeObjectProvider<T>.m_ThreadStaticValue = Activator.CreateInstance<T>();
                    }
                    return MyProject.ThreadSafeObjectProvider<T>.m_ThreadStaticValue;
                }
            }
        }
    }
}

